diff options
Diffstat (limited to 'writerfilter/source/doctok')
71 files changed, 80161 insertions, 0 deletions
diff --git a/writerfilter/source/doctok/Dff.cxx b/writerfilter/source/doctok/Dff.cxx new file mode 100644 index 000000000000..c7d8fb713d6f --- /dev/null +++ b/writerfilter/source/doctok/Dff.cxx @@ -0,0 +1,518 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <stdio.h> +#include "Dff.hxx" +#include <doctok/resourceids.hxx> +#include <resourcemodel/WW8ResourceModel.hxx> +#include "resources.hxx" + +namespace writerfilter { +namespace doctok { + +typedef boost::shared_ptr<WW8Value> WW8ValueSharedPointer_t; + +DffRecord::DffRecord(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 nCount) +: WW8StructBase(rStream, nOffset, nCount), bInitialized(false) +{ +} + +DffRecord::DffRecord(WW8StructBase * pParent, sal_uInt32 nOffset, + sal_uInt32 nCount) +: WW8StructBase(pParent, nOffset, nCount), bInitialized(false) +{ +} + +Records_t::iterator DffRecord::begin() +{ + if (! bInitialized) + initChildren(); + + return mRecords.begin(); +} + +Records_t::iterator DffRecord::end() +{ + if (! bInitialized) + initChildren(); + + return mRecords.end(); +} + +bool DffRecord::isContainer() const +{ + return getVersion() == 0xf; +} + +sal_uInt32 DffRecord::calcSize() const +{ + sal_uInt32 nResult = 0; + + switch (getRecordType()) + { + case 0xf000: + case 0xf001: + case 0xf002: + case 0xf003: + case 0xf004: + nResult = getU32(0x4) + 8; + + break; + case 0xf700: + nResult = 8; + + break; + default: + nResult = getU32(0x4); + + if (! isContainer()) + nResult += 8; + break; + } + + return nResult; +} + +sal_uInt32 DffRecord::getVersion() const +{ + return getU8(0x0) & 0xf; +} + +sal_uInt32 DffRecord::getInstance() const +{ + return (getU16(0x0) & 0xfff0) >> 4; +} + +sal_uInt32 DffRecord::getRecordType() const +{ + return getU16(0x2); +} + +void DffRecord::initChildren() +{ + if (isContainer()) + { + sal_uInt32 nOffset = 8; + sal_uInt32 nCount = calcSize(); + + while (nCount - nOffset >= 8) + { + sal_uInt32 nSize = 0; + boost::shared_ptr<DffRecord> pRec + (createDffRecord(this, nOffset, &nSize)); + + if (nSize == 0) + break; + + mRecords.push_back(pRec); + + nOffset += nSize; + } + } + + bInitialized = true; +} + +Records_t DffRecord::findRecords(sal_uInt32 nType, bool bRecursive, bool bAny) +{ + Records_t aResult; + + findRecords(nType, aResult, bRecursive, bAny); + + return aResult; +} + +void DffRecord::findRecords +(sal_uInt32 nType, Records_t & rRecords, bool bRecursive, bool bAny) +{ + Records_t::iterator aIt = begin(); + + while (aIt != end()) + { + Pointer_t pPointer = *aIt; + if (bAny || pPointer->getRecordType() == nType) + rRecords.push_back(pPointer); + + if (bRecursive) + pPointer->findRecords(nType, rRecords, bRecursive, + bAny); + + ++aIt; + } +} + +void DffRecord::resolveChildren(Properties & rHandler) +{ + Records_t::iterator aIt; + for (aIt = begin(); aIt != end(); ++aIt) + { + rHandler.sprm(**aIt); + } +} + +void DffRecord::resolveLocal(Properties &) +{ +} + +void DffRecord::resolve(Properties & rHandler) +{ + WW8Value::Pointer_t pVal = createValue(getRecordType()); + rHandler.attribute(NS_rtf::LN_dfftype, *pVal); + + pVal = createValue(getInstance()); + rHandler.attribute(NS_rtf::LN_dffinstance, *pVal); + + pVal = createValue(getVersion()); + rHandler.attribute(NS_rtf::LN_dffversion, *pVal); + + pVal = createValue(getU32(0x0)); + rHandler.attribute(NS_rtf::LN_dffheader, *pVal); + + if (isContainer()) + { + resolveChildren(rHandler); + } + + resolveLocal(rHandler); + +#if 1 + WW8BinaryObjReference::Pointer_t pBinObjRef + (new WW8BinaryObjReference(this, 0, getCount())); + WW8Sprm aSprm(pBinObjRef); + + rHandler.sprm(aSprm); +#endif +} + +sal_uInt32 DffRecord::getShapeType() +{ + sal_uInt32 nResult = 0; + + Records_t aRecords = findRecords(0xf00a); + + if (aRecords.size() > 0) + { + DffFSP * pDffFSP = dynamic_cast<DffFSP*>((*aRecords.begin()).get()); + nResult = pDffFSP->get_shptype(); + } + + return nResult; +} + +sal_uInt32 DffRecord::getShapeId() +{ + sal_uInt32 nResult = 0; + + Records_t aRecords = findRecords(0xf00a); + + if (aRecords.size() > 0) + { + DffFSP * pDffFSP = dynamic_cast<DffFSP*>((*aRecords.begin()).get()); + nResult = pDffFSP->get_shpid(); + } + + return nResult; +} + +class DffOPTHandler : public Properties +{ + map<int, WW8ValueSharedPointer_t> mMap; + int nId; + +public: + DffOPTHandler() : nId(0) {} + virtual ~DffOPTHandler() {} + + virtual void attribute(Id name, Value & val) + { + switch (name) + { + case NS_rtf::LN_shppid: + nId = val.getInt(); + break; + case NS_rtf::LN_shpvalue: + { + WW8Value & rTmpVal = dynamic_cast<WW8Value &>(val); + WW8ValueSharedPointer_t + pVal(dynamic_cast<WW8Value *>(rTmpVal.clone())); + mMap[nId] = pVal; + } + } + } + + virtual void sprm(Sprm & /*sprm_*/) + { + } + + WW8ValueSharedPointer_t & getValue(int nId_) + { + return mMap[nId_]; + } + +}; + +sal_uInt32 DffRecord::getShapeBid() +{ + sal_uInt32 nResult = 0; + + if (getShapeType() == 75) + { + Records_t aRecords = findRecords(0xf00b); + + if (aRecords.size() > 0) + { + DffOPTHandler aHandler; + DffOPT * pOpts = dynamic_cast<DffOPT*>((*aRecords.begin()).get()); + + sal_uInt32 nCount = pOpts->get_property_count(); + + for (sal_uInt32 n = 0; n < nCount; ++n) + { + pOpts->get_property(n)->resolve(aHandler); + } + + WW8ValueSharedPointer_t pVal = aHandler.getValue(260); + + if (pVal.get() != NULL) + nResult = pVal->getInt(); + } + } + + return nResult; +} + +string DffRecord::getType() const +{ + return "DffRecord"; +} + +Value::Pointer_t DffRecord::getValue() +{ + return Value::Pointer_t(); +} + +writerfilter::Reference<BinaryObj>::Pointer_t DffRecord::getBinary() +{ + return writerfilter::Reference<BinaryObj>::Pointer_t(); +} + +writerfilter::Reference<Stream>::Pointer_t DffRecord::getStream() +{ + return writerfilter::Reference<Stream>::Pointer_t(); +} + +writerfilter::Reference<Properties>::Pointer_t DffRecord::getProps() +{ + return writerfilter::Reference<Properties>::Pointer_t(this->clone()); +} + +string DffRecord::toString() const +{ + char sBuffer[1024]; + + snprintf(sBuffer, sizeof(sBuffer), + "<dffrecord type=\"%" SAL_PRIuUINT32 "\" instance=\"%" SAL_PRIuUINT32 "\" version=\"%" SAL_PRIuUINT32 "\">\n", + getRecordType(), getInstance(), getVersion()); + string aResult = sBuffer; + + + if (!isContainer()) + aResult += mSequence.toString(); + else + { + WW8StructBase::Sequence aSeq(mSequence, 0, 8); + aResult += aSeq.toString(); + } + + aResult += "</dffrecord>"; + + return aResult; +} + +string DffRecord::getName() const +{ + return ""; +} + +Sprm::Kind DffRecord::getKind() +{ + return Sprm::UNKNOWN; +} + +DffBlock::DffBlock(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 nCount, sal_uInt32 nPadding) +: WW8StructBase(rStream, nOffset, nCount), bInitialized(false), + mnPadding(nPadding) +{ +} + +DffBlock::DffBlock(WW8StructBase * pParent, sal_uInt32 nOffset, + sal_uInt32 nCount, sal_uInt32 nPadding) +: WW8StructBase(pParent, nOffset, nCount), bInitialized(false), + mnPadding(nPadding) +{ +} + +DffBlock::DffBlock(const DffBlock & rSrc) +: WW8StructBase(rSrc), writerfilter::Reference<Properties>(rSrc), + bInitialized(false), mnPadding(rSrc.mnPadding) +{ +} + +void DffBlock::initChildren() +{ + sal_uInt32 nOffset = 0; + sal_uInt32 nCount = getCount(); + + while (nOffset < nCount) + { + sal_uInt32 nSize = 0; + DffRecord::Pointer_t pDffRecord + (createDffRecord(this, nOffset, &nSize)); + + if (nSize == 0) + break; + + mRecords.push_back(pDffRecord); + + nOffset += nSize + mnPadding; + } + + bInitialized = true; +} + +Records_t DffBlock::findRecords(sal_uInt32 nType, bool bRecursive, bool bAny) +{ + Records_t aResult; + + findRecords(nType, aResult, bRecursive, bAny); + + return aResult; +} + +void DffBlock::findRecords +(sal_uInt32 nType, Records_t & rRecords, bool bRecursive, bool bAny) +{ + Records_t::iterator aIt = begin(); + + while (aIt != end()) + { + DffRecord::Pointer_t pPointer(*aIt); + + if (bAny || pPointer->getRecordType() == nType) + rRecords.push_back(pPointer); + + if (bRecursive) + pPointer->findRecords(nType, rRecords, bRecursive, + bAny); + + ++aIt; + } +} + +void DffBlock::resolve(Properties & rHandler) +{ + Records_t::iterator aIt; + + for (aIt = begin(); aIt != end(); ++aIt) + { + DffRecord * pDff = aIt->get(); + rHandler.sprm(*pDff); + } +} + +DffRecord::Pointer_t DffBlock::getShape(sal_uInt32 nSpid) +{ + DffRecord::Pointer_t pResult; + + Records_t aRecords = findRecords(0xf004); + Records_t::iterator aIt; + for (aIt = aRecords.begin(); aIt != aRecords.end(); ++aIt) + { + DffRecord::Pointer_t pPointer = *aIt; + + Records_t aFSPs = pPointer->findRecords(0xf00a); + Records_t::iterator aItFSP = aFSPs.begin(); + + if (aItFSP != aFSPs.end()) + { + DffFSP * pFSP = dynamic_cast<DffFSP *>((*aItFSP).get()); + + if (pFSP->get_shpid() == nSpid) + { + pResult = pPointer; + + break; + } + } + } + + return pResult; +} + +DffRecord::Pointer_t DffBlock::getBlip(sal_uInt32 nBlip) +{ + DffRecord::Pointer_t pResult; + + if (nBlip > 0) + { + nBlip--; + + Records_t aRecords = findRecords(0xf007); + + if (nBlip < aRecords.size()) + { + pResult = aRecords[nBlip]; + } + } + + return pResult; +} + +Records_t::iterator DffBlock::begin() +{ + if (! bInitialized) + initChildren(); + + return mRecords.begin(); +} + +Records_t::iterator DffBlock::end() +{ + if (! bInitialized) + initChildren(); + + return mRecords.end(); +} + +string DffBlock::getType() const +{ + return "DffBlock"; +} + +}} diff --git a/writerfilter/source/doctok/Dff.hxx b/writerfilter/source/doctok/Dff.hxx new file mode 100644 index 000000000000..b0a64f05c303 --- /dev/null +++ b/writerfilter/source/doctok/Dff.hxx @@ -0,0 +1,153 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_DFF_HXX +#define INCLUDED_DFF_HXX + +#include <vector> +#include <WW8StructBase.hxx> +#include <WW8ResourceModelImpl.hxx> + +namespace writerfilter { +namespace doctok +{ +using std::vector; + +class DffBlock; + +class DffRecord : public WW8StructBase, public writerfilter::Reference<Properties>, + public Sprm +{ + bool bInitialized; +public: + typedef boost::shared_ptr<DffRecord> Pointer_t; + +protected: + typedef vector<Pointer_t> Records_t; + Records_t mRecords; + + void initChildren(); + +public: + + DffRecord(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount); + DffRecord(WW8StructBase * pParent, sal_uInt32 nOffset, sal_uInt32 nCount); + virtual ~DffRecord() {} + + bool isContainer() const; + sal_uInt32 calcSize() const; + + sal_uInt32 getVersion() const; + sal_uInt32 getInstance() const; + sal_uInt32 getRecordType() const; + + virtual DffRecord * clone() const { return new DffRecord(*this); } + + virtual void resolveLocal(Properties & rHandler); + virtual void resolveChildren(Properties & rHandler); + + Records_t findRecords(sal_uInt32 nType, bool bRecursive = true, + bool bAny = false); + + void findRecords + (sal_uInt32 nType, Records_t & rRecords, + bool bRecursive = true, bool bAny = false); + + Records_t::iterator begin(); + Records_t::iterator end(); + + sal_uInt32 getShapeType(); + sal_uInt32 getShapeId(); + sal_uInt32 getShapeBid(); + + /* Properties methods */ + virtual void resolve(Properties & rHandler); + virtual string getType() const; + + /* Sprm methods */ + virtual sal_uInt32 getId() const { return getRecordType(); } + virtual Value::Pointer_t getValue(); + virtual writerfilter::Reference<BinaryObj>::Pointer_t getBinary(); + virtual writerfilter::Reference<Stream>::Pointer_t getStream(); + virtual writerfilter::Reference<Properties>::Pointer_t getProps(); + + virtual string toString() const; + virtual string getName() const; + + virtual Kind getKind(); + + friend class DffBlock; +}; + +typedef vector<DffRecord::Pointer_t> Records_t; + +class DffBlock : public WW8StructBase, + public writerfilter::Reference<Properties> +{ + bool bInitialized; + sal_uInt32 mnPadding; + + Records_t mRecords; + +protected: + void initChildren(); + +public: + typedef boost::shared_ptr<DffBlock> Pointer_t; + + DffBlock(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount, sal_uInt32 nPadding); + DffBlock(WW8StructBase * pParent, sal_uInt32 nOffset, sal_uInt32 nCount, sal_uInt32 nPadding); + DffBlock(const DffBlock & rSrc); + virtual ~DffBlock() {} + + Records_t findRecords(sal_uInt32 nType, bool bRecursive = true, + bool bAny = false); + + void findRecords(sal_uInt32 nType, Records_t & rRecords, + bool bRecursive = true, bool bAny = false); + + DffRecord::Pointer_t getShape(sal_uInt32 nSpid); + DffRecord::Pointer_t getBlip(sal_uInt32 nBlip); + + Records_t::iterator begin(); + Records_t::iterator end(); + + /* Properties methods */ + virtual void resolve(Properties & rHandler); + virtual string getType() const; +}; + +DffRecord * +createDffRecord(WW8StructBase * pParent, sal_uInt32 nOffset, + sal_uInt32 * nSize = NULL); +DffRecord * +createDffRecord(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 * nSize = NULL); + +}} + +#endif diff --git a/writerfilter/source/doctok/DffImpl.cxx b/writerfilter/source/doctok/DffImpl.cxx new file mode 100644 index 000000000000..fcb2fe6267be --- /dev/null +++ b/writerfilter/source/doctok/DffImpl.cxx @@ -0,0 +1,518 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include "resources.hxx" +#include "WW8DocumentImpl.hxx" + +namespace writerfilter { +namespace doctok +{ + +class ShapeTypeToString +{ + typedef boost::shared_ptr<ShapeTypeToString> Pointer_t; + + static Pointer_t pInstance; + + typedef map<sal_uInt32, string> Map_t; + Map_t mMap; + +protected: + ShapeTypeToString(); + +public: + static Pointer_t Instance() + { + if (pInstance == NULL) + pInstance = Pointer_t(new ShapeTypeToString()); + + return pInstance; + } + + string operator()(sal_uInt32 nShapeType) + { + return mMap[nShapeType]; + } +}; + +ShapeTypeToString::Pointer_t ShapeTypeToString::pInstance; + +ShapeTypeToString::ShapeTypeToString() +{ + mMap[0]="NotPrimitive"; + mMap[1]="Rectangle"; + mMap[2]="RoundRectangle"; + mMap[3]="Ellipse"; + mMap[4]="Diamond"; + mMap[5]="IsocelesTriangle"; + mMap[6]="RightTriangle"; + mMap[7]="Parallelogram"; + mMap[8]="Trapezoid"; + mMap[9]="Hexagon"; + mMap[10]="Octagon"; + mMap[11]="Plus"; + mMap[12]="Star"; + mMap[13]="Arrow"; + mMap[14]="ThickArrow"; + mMap[15]="HomePlate"; + mMap[16]="Cube"; + mMap[17]="Balloon"; + mMap[18]="Seal"; + mMap[19]="Arc"; + mMap[20]="Line"; + mMap[21]="Plaque"; + mMap[22]="Can"; + mMap[23]="Donut"; + mMap[24]="TextSimple"; + mMap[25]="TextOctagon"; + mMap[26]="TextHexagon"; + mMap[27]="TextCurve"; + mMap[28]="TextWave"; + mMap[29]="TextRing"; + mMap[30]="TextOnCurve"; + mMap[31]="TextOnRing"; + mMap[32]="StraightConnector1"; + mMap[33]="BentConnector2"; + mMap[34]="BentConnector3"; + mMap[35]="BentConnector4"; + mMap[36]="BentConnector5"; + mMap[37]="CurvedConnector2"; + mMap[38]="CurvedConnector3"; + mMap[39]="CurvedConnector4"; + mMap[40]="CurvedConnector5"; + mMap[41]="Callout1"; + mMap[42]="Callout2"; + mMap[43]="Callout3"; + mMap[44]="AccentCallout1"; + mMap[45]="AccentCallout2"; + mMap[46]="AccentCallout3"; + mMap[47]="BorderCallout1"; + mMap[48]="BorderCallout2"; + mMap[49]="BorderCallout3"; + mMap[50]="AccentBorderCallout1"; + mMap[51]="AccentBorderCallout2"; + mMap[52]="AccentBorderCallout3"; + mMap[53]="Ribbon"; + mMap[54]="Ribbon2"; + mMap[55]="Chevron"; + mMap[56]="Pentagon"; + mMap[57]="NoSmoking"; + mMap[58]="Seal8"; + mMap[59]="Seal16"; + mMap[60]="Seal32"; + mMap[61]="WedgeRectCallout"; + mMap[62]="WedgeRRectCallout"; + mMap[63]="WedgeEllipseCallout"; + mMap[64]="Wave"; + mMap[65]="FoldedCorner"; + mMap[66]="LeftArrow"; + mMap[67]="DownArrow"; + mMap[68]="UpArrow"; + mMap[69]="LeftRightArrow"; + mMap[70]="UpDownArrow"; + mMap[71]="IrregularSeal1"; + mMap[72]="IrregularSeal2"; + mMap[73]="LightningBolt"; + mMap[74]="Heart"; + mMap[75]="PictureFrame"; + mMap[76]="QuadArrow"; + mMap[77]="LeftArrowCallout"; + mMap[78]="RightArrowCallout"; + mMap[79]="UpArrowCallout"; + mMap[80]="DownArrowCallout"; + mMap[81]="LeftRightArrowCallout"; + mMap[82]="UpDownArrowCallout"; + mMap[83]="QuadArrowCallout"; + mMap[84]="Bevel"; + mMap[85]="LeftBracket"; + mMap[86]="RightBracket"; + mMap[87]="LeftBrace"; + mMap[88]="RightBrace"; + mMap[89]="LeftUpArrow"; + mMap[90]="BentUpArrow"; + mMap[91]="BentArrow"; + mMap[92]="Seal24"; + mMap[93]="StripedRightArrow"; + mMap[94]="NotchedRightArrow"; + mMap[95]="BlockArc"; + mMap[96]="SmileyFace"; + mMap[97]="VerticalScroll"; + mMap[98]="HorizontalScroll"; + mMap[99]="CircularArrow"; + mMap[100]="NotchedCircularArrow"; + mMap[101]="UturnArrow"; + mMap[102]="CurvedRightArrow"; + mMap[103]="CurvedLeftArrow"; + mMap[104]="CurvedUpArrow"; + mMap[105]="CurvedDownArrow"; + mMap[106]="CloudCallout"; + mMap[107]="EllipseRibbon"; + mMap[108]="EllipseRibbon2"; + mMap[109]="FlowChartProcess"; + mMap[110]="FlowChartDecision"; + mMap[111]="FlowChartInputOutput"; + mMap[112]="FlowChartPredefinedProcess"; + mMap[113]="FlowChartInternalStorage"; + mMap[114]="FlowChartDocument"; + mMap[115]="FlowChartMultidocument"; + mMap[116]="FlowChartTerminator"; + mMap[117]="FlowChartPreparation"; + mMap[118]="FlowChartManualInput"; + mMap[119]="FlowChartManualOperation"; + mMap[120]="FlowChartConnector"; + mMap[121]="FlowChartPunchedCard"; + mMap[122]="FlowChartPunchedTape"; + mMap[123]="FlowChartSummingJunction"; + mMap[124]="FlowChartOr"; + mMap[125]="FlowChartCollate"; + mMap[126]="FlowChartSort"; + mMap[127]="FlowChartExtract"; + mMap[128]="FlowChartMerge"; + mMap[129]="FlowChartOfflineStorage"; + mMap[130]="FlowChartOnlineStorage"; + mMap[131]="FlowChartMagneticTape"; + mMap[132]="FlowChartMagneticDisk"; + mMap[133]="FlowChartMagneticDrum"; + mMap[134]="FlowChartDisplay"; + mMap[135]="FlowChartDelay"; + mMap[136]="TextPlainText"; + mMap[137]="TextStop"; + mMap[138]="TextTriangle"; + mMap[139]="TextTriangleInverted"; + mMap[140]="TextChevron"; + mMap[141]="TextChevronInverted"; + mMap[142]="TextRingInside"; + mMap[143]="TextRingOutside"; + mMap[144]="TextArchUpCurve"; + mMap[145]="TextArchDownCurve"; + mMap[146]="TextCircleCurve"; + mMap[147]="TextButtonCurve"; + mMap[148]="TextArchUpPour"; + mMap[149]="TextArchDownPour"; + mMap[150]="TextCirclePour"; + mMap[151]="TextButtonPour"; + mMap[152]="TextCurveUp"; + mMap[153]="TextCurveDown"; + mMap[154]="TextCascadeUp"; + mMap[155]="TextCascadeDown"; + mMap[156]="TextWave1"; + mMap[157]="TextWave2"; + mMap[158]="TextWave3"; + mMap[159]="TextWave4"; + mMap[160]="TextInflate"; + mMap[161]="TextDeflate"; + mMap[162]="TextInflateBottom"; + mMap[163]="TextDeflateBottom"; + mMap[164]="TextInflateTop"; + mMap[165]="TextDeflateTop"; + mMap[166]="TextDeflateInflate"; + mMap[167]="TextDeflateInflateDeflate"; + mMap[168]="TextFadeRight"; + mMap[169]="TextFadeLeft"; + mMap[170]="TextFadeUp"; + mMap[171]="TextFadeDown"; + mMap[172]="TextSlantUp"; + mMap[173]="TextSlantDown"; + mMap[174]="TextCanUp"; + mMap[175]="TextCanDown"; + mMap[176]="FlowChartAlternateProcess"; + mMap[177]="FlowChartOffpageConnector"; + mMap[178]="Callout90"; + mMap[179]="AccentCallout90"; + mMap[180]="BorderCallout90"; + mMap[181]="AccentBorderCallout90"; + mMap[182]="LeftRightUpArrow"; + mMap[183]="Sun"; + mMap[184]="Moon"; + mMap[185]="BracketPair"; + mMap[186]="BracePair"; + mMap[187]="Seal4"; + mMap[188]="DoubleWave"; + mMap[189]="ActionButtonBlank"; + mMap[190]="ActionButtonHome"; + mMap[191]="ActionButtonHelp"; + mMap[192]="ActionButtonInformation"; + mMap[193]="ActionButtonForwardNext"; + mMap[194]="ActionButtonBackPrevious"; + mMap[195]="ActionButtonEnd"; + mMap[196]="ActionButtonBeginning"; + mMap[197]="ActionButtonReturn"; + mMap[198]="ActionButtonDocument"; + mMap[199]="ActionButtonSound"; + mMap[200]="ActionButtonMovie"; + mMap[201]="HostControl"; + mMap[202]="TextBox"; +} + +// DffOPT + +sal_uInt32 DffOPT::get_property_count() +{ + return getInstance(); +} + +writerfilter::Reference<Properties>::Pointer_t +DffOPT::get_property(sal_uInt32 nPos) +{ + WW8FOPTE * pTmp = new WW8FOPTE(this, 0x8 + nPos * WW8FOPTE::getSize()); + pTmp->setIndex(nPos); + + return writerfilter::Reference<Properties>::Pointer_t(pTmp); +} + +sal_uInt32 DffOPT::get_extraoffset_count() +{ + return get_property_count(); +} + +sal_uInt32 DffOPT::get_extraoffset(sal_uInt32 pos) +{ + sal_uInt32 nResult; + sal_uInt32 nCount = get_property_count(); + + if (pos < nCount) + { + nResult = 0x8 + nCount * WW8FOPTE::getSize(); + + for (sal_uInt32 n = 0; n < pos; ++n) + { + WW8FOPTE aFOPTE(this, 0x8 + n * WW8FOPTE::getSize()); + + if (aFOPTE.get_fComplex()) + { + sal_uInt32 nValue = aFOPTE.get_op(); + nResult += nValue; + } + } + } + else + nResult = getCount(); + + return nResult; +} + +//DffDGG + +sal_uInt32 DffDGG::get_fidcl_count() +{ + return (getCount() - 0x18) / WW8FIDCL::getSize(); +} + +writerfilter::Reference<Properties>::Pointer_t +DffDGG::get_fidcl(sal_uInt32 pos) +{ + return writerfilter::Reference<Properties>::Pointer_t + (new WW8FIDCL(this, 0x18 + pos * WW8FIDCL::getSize())); +} + + +// DffBSE + +rtl::OUString DffBSE::get_blipname() +{ + rtl::OUString sResult; + WW8FBSE aFBSE(this, 0x8); + + if (aFBSE.get_cbName() > 0) + sResult = getString(0x24, aFBSE.get_cbName()); + + return sResult; +} + +writerfilter::Reference<Properties>::Pointer_t +DffBSE::get_blip() +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + WW8FBSE aFBSE(this, 8); + sal_uInt32 nOffset = 8 + WW8FBSE::getSize() + aFBSE.get_cbName(); + + if (nOffset + 8 < getCount()) + { + WW8StructBase aTmp(this, nOffset, 0x8); + + sal_uInt32 nCount = getCount() - 8; + + if (aTmp.getU32(0x4) - 8 < nCount) + nCount = aTmp.getU32(0x4) - 8; + + if (nCount) + { + DffRecord * pRecord = createDffRecord(this, nOffset); + + pResult = writerfilter::Reference<Properties>::Pointer_t(pRecord); + } + } + else + { + nOffset = sal::static_int_cast<sal_Int32>(aFBSE.get_foDelay()); + if (! (nOffset & 1 << 31) && nOffset > 0 && getDocument() != NULL) + { + WW8StructBase aStructBase(*getDocument()->getDocStream(), + nOffset, 0x8); + + DffRecord * pRecord = + createDffRecord(*getDocument()->getDocStream(), + aFBSE.get_foDelay()); + + pResult = writerfilter::Reference<Properties>::Pointer_t(pRecord); + } + } + + return pResult; +} + +#if 0 +WW8BinaryObjReference::Pointer_t DffBSE::get_binary() +{ + WW8BinaryObjReference::Pointer_t pResult; + + if (getCount() > 0x45) + pResult = WW8BinaryObjReference::Pointer_t + (new WW8BinaryObjReference(this, 0x45, + getCount() - 0x45)); + else + { + WW8FBSE aFBSE(this, 0x8); + + sal_Int32 nOffset = sal::static_int_cast<sal_Int32>(aFBSE.get_foDelay()); + if (nOffset > 0 && getDocument() != NULL) + { + WW8StructBase aStructBase(*getDocument()->getDocStream(), + nOffset, 0x8); + + sal_uInt32 nCount = aStructBase.getU32(0x4) - 0x11; + + pResult = WW8BinaryObjReference::Pointer_t + (new WW8BinaryObjReference(*getDocument()->getDocStream(), + aFBSE.get_foDelay() + 0x19, nCount)); + } + } + + return pResult; +} +#endif + +// WW8FOPTE +void WW8FOPTE::resolveNoAuto(Properties & rHandler) +{ + sal_uInt16 nId = get_pid() + 1; + sal_uInt32 nOp = get_op(); + sal_uInt32 nMask = 2; + + while (isBooleanDffOpt(nId)) + { + WW8Value::Pointer_t pVal = createValue(getDffOptName(nId)); + rHandler.attribute(NS_rtf::LN_shpname, *pVal); + + pVal = createValue((nOp & nMask) != 0); + rHandler.attribute(NS_rtf::LN_shpvalue, *pVal); + + --nId; + nMask = nMask << 1; + } +} + +// DffFSP + +rtl::OUString DffFSP::get_shptypename() +{ + string aName = (*ShapeTypeToString::Instance())(get_shptype()); + + return rtl::OUString::createFromAscii(aName.c_str()); +} + +// DffSpContainer + +writerfilter::Reference<Properties>::Pointer_t +DffSpContainer::get_blip() +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + if (getShapeType() == 75) + { + sal_uInt32 nBid = getShapeBid(); + + if (getDocument() != NULL && nBid > 0) + pResult = getDocument()->getBlip(nBid); + } + + return pResult; +} + +writerfilter::Reference<Stream>::Pointer_t +DffSpContainer::get_shptxt() +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (getShapeType() == 202) + { + sal_uInt32 nShpId = getShapeId(); + + if (getDocument() != NULL) + pResult = getDocument()->getTextboxText(nShpId); + } + + return pResult; +} + +// DffUDefProp + +void DffUDefProp::resolveNoAuto(Properties & rHandler) +{ + sal_uInt32 nOffset = 0x8; + sal_uInt32 nCount = getCount(); + + while (nOffset + 6 <= nCount) + { + sal_uInt16 nPid = getU16(nOffset); + sal_uInt32 nValue = getU32(nOffset + 2); + + sal_uInt32 nAttrid = 0; + switch (nPid) + { + case 0x38f: nAttrid = NS_rtf::LN_XAlign; break; + case 0x390: nAttrid = NS_rtf::LN_XRelTo; break; + case 0x391: nAttrid = NS_rtf::LN_YAlign; break; + case 0x392: nAttrid = NS_rtf::LN_YRelTo; break; + case 0x3bf: nAttrid = NS_rtf::LN_LayoutInTableCell; break; + case 0x53f: nAttrid = NS_rtf::LN_Inline; break; + default: + break; + } + + if (nAttrid != 0) + { + WW8Value::Pointer_t pVal = createValue(nValue); + rHandler.attribute(nAttrid, *pVal); + } + + nOffset += 6; + } +} + +}} diff --git a/writerfilter/source/doctok/PLCF.hxx b/writerfilter/source/doctok/PLCF.hxx new file mode 100644 index 000000000000..fefff12f6c11 --- /dev/null +++ b/writerfilter/source/doctok/PLCF.hxx @@ -0,0 +1,195 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_PLCF_HXX +#define INCLUDED_PLCF_HXX + +#include <boost/shared_ptr.hpp> +#include <WW8StructBase.hxx> + +namespace writerfilter { +namespace doctok +{ + +class Empty +{ +public: + typedef boost::shared_ptr<Empty> Pointer_t; + + Empty() {} + virtual ~Empty() {} + + sal_uInt32 getSize() { return 0; } +}; + +template <class T> +/** + Plex in File + + A PLCF is a concatenation of two arrays. The first array contains + file character positions. The second array contains elements of + type T. If the first array contains N elements, the second contains + N - 1 elements. The N-th element in the first array corresponds to + the N-th element of the second array. + + The second array is referred to as the payload. + */ +class PLCF : public WW8StructBase +{ + /// number of entries + sal_uInt32 nEntryCount; + + /// offset to payload + sal_uInt32 nPayloadOffset; + + /// internal method to calculate the number of entries + sal_uInt32 getEntryCount_() const; + +public: + typedef boost::shared_ptr< PLCF< T > > Pointer_t; + + PLCF(sal_uInt32 nLength) + : WW8StructBase(nLength), nEntryCount(getEntryCount_()), + nPayloadOffset((nEntryCount + 1) * 4) + { + } + + PLCF(WW8Stream & rStream, + sal_Int32 nOffset, sal_Int32 nCount) + : WW8StructBase(rStream, nOffset, nCount), + nEntryCount(getEntryCount_()), + nPayloadOffset((nEntryCount + 1) * 4) + { + } + + PLCF(const Sequence & rSequence) + : WW8StructBase(rSequence), nEntryCount(getEntryCount_()), + nPayloadOffset((nEntryCount + 1) * 4) + { + } + + /** + Return the number of elements in the PLCF- + */ + sal_uInt32 getEntryCount() const { return nEntryCount; } + + /** + Return the file character position of a certain element. + + @param nIndex the index of the element + */ + sal_uInt32 getFc(sal_uInt32 nIndex) const; + + /** + Return a C++ pointer to a certain payload entry. + + @param nIndex the index of the element + */ + T * getEntryPointer(sal_uInt32 nIndex) const; + + /** + Return a shared pointer to a certain payload element. + + @param nIndex the index of the element + */ + typename T::Pointer_t getEntry(sal_uInt32 nIndex) const; + + /** + Return a C++ pointer a certain payload element. + + @param nFc the file character position of the element + */ + T * getEntryByFc(sal_uInt32 nFc) const; + + virtual void dump(OutputWithDepth<string> & out) const; +}; + +template <class T> +sal_uInt32 PLCF<T>::getEntryCount_() const +{ + return (getCount() - 4) / (T::getSize() + 4); +} + +template <class T> +sal_uInt32 PLCF<T>::getFc(sal_uInt32 nIndex) const +{ + return getU32(nIndex * 4); +} + +template <class T> +T * PLCF<T>::getEntryPointer(sal_uInt32 nIndex) const +{ + return new T(mSequence, nPayloadOffset + nIndex * T::getSize(), + T::getSize()); +} + +template <class T> +typename T::Pointer_t PLCF<T>::getEntry(sal_uInt32 nIndex) const +{ + typename T::Pointer_t pResult(getEntryPointer(nIndex)); + + return pResult; +} + + +template <class T> +T * PLCF<T>::getEntryByFc(sal_uInt32 nFc) const +{ + T * pResult = NULL; + + sal_uInt32 n = getEntryCount(); + + while (getFc(n) > nFc) + n--; + + pResult = getEntryPointer(n); + + return pResult; +} + +template <class T> +void PLCF<T>::dump(OutputWithDepth<string> & output_) const +{ + output_.addItem("<plcf>"); + WW8StructBase::dump(output_); + + sal_uInt32 nCount = getEntryCount(); + for (sal_uInt32 n = 0; n < nCount; ++n) + { + Fc aFc = getFc(n); + typename T::Pointer_t pT = getEntry(n); + + output_.addItem("<plcfentry cpandfc=\"" + aFc.toString() + "\">"); + pT->dump(output_); + output_.addItem("</plcfentry>"); + } + output_.addItem("</plcf>>"); +} + +}} + +#endif // INCLUDED_PLCF_HXX diff --git a/writerfilter/source/doctok/WW8Annotation.cxx b/writerfilter/source/doctok/WW8Annotation.cxx new file mode 100644 index 000000000000..aabcd5525e90 --- /dev/null +++ b/writerfilter/source/doctok/WW8Annotation.cxx @@ -0,0 +1,37 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> + +namespace writerfilter { +namespace doctok +{ +rtl::OUString WW8ATRD::get_xstUsrInitl() +{ + return getString(0x0); +} +}} diff --git a/writerfilter/source/doctok/WW8BinTable.hxx b/writerfilter/source/doctok/WW8BinTable.hxx new file mode 100644 index 000000000000..4105a06b5fd4 --- /dev/null +++ b/writerfilter/source/doctok/WW8BinTable.hxx @@ -0,0 +1,88 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_BIN_TABLE_HXX +#define INCLUDED_WW8_BIN_TABLE_HXX + +#include <boost/shared_ptr.hpp> +#include <string> +#include <WW8FKP.hxx> + +namespace writerfilter { +namespace doctok +{ + +/** + A bintable. + + Word uses bintables to associate FC ranges with FKPs. A bintable + has a list of FCs. At each FC a range begins. The length of the + range is given by the distance of the according CPs. + */ +class WW8BinTable +{ +public: + virtual ~WW8BinTable() {}; + /** + Shared pointer to a bintable. + */ + typedef boost::shared_ptr<WW8BinTable> Pointer_t; + + /** + Return count of entries. + */ + virtual sal_uInt32 getEntryCount() const = 0; + + /** + Return FC from bintable. + + @param nIndex index in bintable to return FC from + */ + virtual Fc getFc(sal_uInt32 nIndex) const = 0; + + /** + Return page number. + + @param nIndex index in bintable to return page number from + */ + virtual sal_uInt32 getPageNumber(sal_uInt32 nIndex) const = 0; + + /** + Return page number associated with FC. + + @param rFc FC to return page number for + */ + virtual sal_uInt32 getPageNumber(const Fc & rFc) const = 0; + + /** + Return string representation of bintable. + */ + virtual string toString() const = 0; +}; +}} + +#endif // INCLUDED_WW8_BIN_TABLE_HXX diff --git a/writerfilter/source/doctok/WW8BinTableImpl.cxx b/writerfilter/source/doctok/WW8BinTableImpl.cxx new file mode 100644 index 000000000000..05959cf359b1 --- /dev/null +++ b/writerfilter/source/doctok/WW8BinTableImpl.cxx @@ -0,0 +1,106 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include "WW8BinTableImpl.hxx" + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +void PageNumber::dump(OutputWithDepth<string> & /*output*/) const +{ +} + +sal_uInt32 WW8BinTableImpl::getPageNumber(const Fc & rFc) const +{ + sal_uInt32 nResult = 0; + + if (mPageMap.find(rFc) == mPageMap.end()) + { +#if 0 + sal_uInt32 n = getEntryCount(); + + while (rFc < getFc(n)) + { + --n; + } + + nResult = getPageNumber(n); + mPageMap[rFc] = nResult; +#else + sal_uInt32 left = 0; + sal_uInt32 right = getEntryCount(); + + while (right - left > 1) + { + sal_uInt32 middle = (right + left) / 2; + + Fc aFc = getFc(middle); + + if (rFc < aFc) + right = middle; + else + left = middle; + + } + + nResult = getPageNumber(left); + mPageMap[rFc] = nResult; +#endif + + } + else + nResult = mPageMap[rFc]; + + return nResult; +} + +string WW8BinTableImpl::toString() const +{ + string aResult; + char sBuffer[255]; + + aResult += "("; + + for (sal_uInt32 n = 0; n < getEntryCount(); n++) + { + if (n > 0) + aResult += ", "; + + snprintf(sBuffer, 255, "%" SAL_PRIxUINT32, getFc(n).get()); + aResult += sBuffer; + aResult += "->"; + snprintf(sBuffer, 255, "%" SAL_PRIxUINT32, getPageNumber(n)); + aResult += sBuffer; + } + + aResult += ")"; + + return aResult; +} +}} diff --git a/writerfilter/source/doctok/WW8BinTableImpl.hxx b/writerfilter/source/doctok/WW8BinTableImpl.hxx new file mode 100644 index 000000000000..d3119c13dd20 --- /dev/null +++ b/writerfilter/source/doctok/WW8BinTableImpl.hxx @@ -0,0 +1,98 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_BIN_TABLE_IMPL_HXX +#define INCLUDED_WW8_BIN_TABLE_IMPL_HXX + +#include <istream> +#include <WW8BinTable.hxx> +#include <PLCF.hxx> + +#include <hash_map> + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +/** + A number of a FKP. + */ +class PageNumber +{ + /// the page number + sal_uInt32 mnPageNumber; + +public: + /// Pointer to a page number + typedef boost::shared_ptr<PageNumber> Pointer_t; + + /// get size of a page number + static size_t getSize() { return 4; } + + PageNumber(WW8StructBase::Sequence & rSeq, sal_uInt32 nOffset, + sal_uInt32 /*nCount*/) + : mnPageNumber(getU32(rSeq, nOffset)) + { + } + + /// Return the page number + sal_uInt32 get() const { return mnPageNumber; } + + virtual void dump(OutputWithDepth<string> & out) const; +}; + +/** + Implementation class for a binary table + */ +class WW8BinTableImpl : public WW8BinTable +{ + /// PLCF containing the numbers of the FKPs of the binary table + PLCF<PageNumber> mData; + mutable hash_map<Fc, sal_uInt32, FcHash> mPageMap; + +public: + WW8BinTableImpl(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 nCount) + : mData(rStream, nOffset, nCount) + + { + } + + virtual sal_uInt32 getEntryCount() const + { return mData.getEntryCount(); } + virtual Fc getFc(sal_uInt32 nIndex) const + { return mData.getFc(nIndex); } + virtual sal_uInt32 getPageNumber(sal_uInt32 nIndex) const + { return mData.getEntry(nIndex)->get(); } + virtual sal_uInt32 getPageNumber(const Fc & rFc) const; + virtual string toString() const; +}; + +}} + +#endif // INCLUDED_WW8_BIN_TABLE_IMPL_HXX diff --git a/writerfilter/source/doctok/WW8Clx.cxx b/writerfilter/source/doctok/WW8Clx.cxx new file mode 100644 index 000000000000..d794afd3ce60 --- /dev/null +++ b/writerfilter/source/doctok/WW8Clx.cxx @@ -0,0 +1,84 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <com/sun/star/io/XSeekable.hpp> +#include <WW8Clx.hxx> +#include <resources.hxx> + +namespace writerfilter { +namespace doctok +{ +WW8Clx::WW8Clx(WW8Stream & rStream, + sal_uInt32 nOffset, sal_uInt32 nCount) +: WW8StructBase(rStream, nOffset, nCount), nOffsetPieceTable(0) +{ + while (getU8(nOffsetPieceTable) != 2) + { + nOffsetPieceTable += getU16(nOffsetPieceTable + 1) + 3; + } +} + +sal_uInt32 WW8Clx::getPieceCount() const +{ + return (getU32(nOffsetPieceTable + 1) - 4) / 12; +} + +sal_uInt32 WW8Clx::getCp(sal_uInt32 nIndex) const +{ + return getU32(nOffsetPieceTable + 5 + nIndex * 4); +} + +sal_uInt32 WW8Clx::getFc(sal_uInt32 nIndex) const +{ + sal_uInt32 nResult = getU32(nOffsetPieceTable + 5 + + (getPieceCount() + 1) * 4 + + nIndex * 8 + 2); + + if (nResult & 0x40000000) + nResult = (nResult & ~0x40000000) / 2; + + return nResult; +} + +sal_Bool WW8Clx::isComplexFc(sal_uInt32 nIndex) const +{ + sal_Bool bResult = sal_False; + sal_uInt32 nTmp = getU32(nOffsetPieceTable + 5 + + (getPieceCount() + 1) * 4 + + nIndex * 8 + 2); + if (nTmp & 0x40000000) + bResult = sal_True; + + return bResult; +} + +void WW8Clx::dump(OutputWithDepth<string> & o) const +{ + WW8StructBase::dump(o); +} + +}} diff --git a/writerfilter/source/doctok/WW8Clx.hxx b/writerfilter/source/doctok/WW8Clx.hxx new file mode 100644 index 000000000000..7085965a689a --- /dev/null +++ b/writerfilter/source/doctok/WW8Clx.hxx @@ -0,0 +1,93 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_CLX_HXX +#define INCLUDED_WW8_CLX_HXX + +#include <resources.hxx> + +#ifndef INCLUDED_WW8_OUTPUT_WITH_DEPTH_HXX +#include <WW8OutputWithDepth.hxx> +#endif + +namespace writerfilter { +namespace doctok +{ + +/** + Piece table as stored in a Word file. + + It contains character positions (CPs) and file character positions + (FCs). Each CP is correlated to one FC. + */ +class WW8Clx : public WW8StructBase +{ + /// Pointer to the file information block. + WW8Fib::Pointer_t pFib; + + /// Offset where FCs begin + sal_uInt32 nOffsetPieceTable; + +public: + /// Pointer to Clx. + typedef boost::shared_ptr<WW8Clx> Pointer_t; + + WW8Clx(WW8Stream & rStream, + sal_uInt32 nOffset, sal_uInt32 nCount); + + virtual void dump(OutputWithDepth<string> & o) const; + + /** + Return the number of pieces. + */ + sal_uInt32 getPieceCount() const; + + /** + Return a certain character position. + + @param nIndex index of the character position + */ + sal_uInt32 getCp(sal_uInt32 nIndex) const; + + /** + Return a certain file character position. + + @param nIndex index of the file character position + */ + sal_uInt32 getFc(sal_uInt32 nIndex) const; + + /** + Return if a certain FC is complex. + + @nIndex index of the FC + */ + sal_Bool isComplexFc(sal_uInt32 nIndex) const; + +}; +}} + +#endif diff --git a/writerfilter/source/doctok/WW8CpAndFc.cxx b/writerfilter/source/doctok/WW8CpAndFc.cxx new file mode 100644 index 000000000000..ecf5f895e91f --- /dev/null +++ b/writerfilter/source/doctok/WW8CpAndFc.cxx @@ -0,0 +1,130 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <WW8CpAndFc.hxx> + +#include <iterator> +#include <algorithm> +#include <string> +#include <map> + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +bool operator < (const Cp & rA, const Cp & rB) +{ + return rA.nCp < rB.nCp; +} + +bool operator == (const Cp & rA, const Cp & rB) +{ + return rA.nCp == rB.nCp; +} + +string Cp::toString() const +{ + char sBuffer[256]; + + snprintf(sBuffer, 255, "%" SAL_PRIxUINT32 "", get()); + + return string(sBuffer); +} + +ostream & operator << (ostream & o, const Cp & rCp) +{ + return o << rCp.toString(); +} + +bool operator < (const Fc & rA, const Fc & rB) +{ + return rA.mnFc < rB.mnFc; +} + +bool operator == (const Fc & rA, const Fc & rB) +{ + return rA.mnFc == rB.mnFc; +} + +string Fc::toString() const +{ + char sBuffer[256]; + + snprintf(sBuffer, 255, "(%" SAL_PRIxUINT32 ", %s)", static_cast<sal_uInt32>(get()), + isComplex() ? "true" : "false"); + + return string(sBuffer); +} + +ostream & operator << (ostream & o, const Fc & rFc) +{ + + return o << rFc.toString(); +} + +bool operator < (const CpAndFc & rA, const CpAndFc & rB) +{ + bool bResult = false; + + if (rA.mCp < rB.mCp) + bResult = true; + else if (rA.mCp == rB.mCp && rA.mType < rB.mType) + bResult = true; + + return bResult; +} + +bool operator == (const CpAndFc & rA, const CpAndFc & rB) +{ + return rA.mCp == rB.mCp; +} + +ostream & operator << (ostream & o, const CpAndFc & rCpAndFc) +{ + return o << rCpAndFc.toString(); +} + +ostream & operator << (ostream & o, const CpAndFcs & rCpAndFcs) +{ + copy(rCpAndFcs.begin(), rCpAndFcs.end(), + ostream_iterator<CpAndFc>(o, ", ")); + + char sBuffer[256]; + + snprintf(sBuffer, 255, "%" SAL_PRI_SIZET "u", rCpAndFcs.size()); + o << sBuffer; + + return o; +} + +CpAndFc::CpAndFc(const Cp & rCp, const Fc & rFc, PropertyType eType_) +: mCp(rCp), mFc(rFc), mType(eType_) +{ +} + +}} diff --git a/writerfilter/source/doctok/WW8CpAndFc.hxx b/writerfilter/source/doctok/WW8CpAndFc.hxx new file mode 100644 index 000000000000..86a8b971a7d6 --- /dev/null +++ b/writerfilter/source/doctok/WW8CpAndFc.hxx @@ -0,0 +1,360 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_CP_AND_FC_HXX +#define INCLUDED_WW8_CP_AND_FC_HXX + +#include <sal/types.h> +#ifndef INCLUDED_DOCUMENT_HXX +#include <doctok/WW8Document.hxx> +#endif +#include <set> +#include <hash_map> +#include <iostream> + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +template <class T> +bool operator <= (const T & rA, const T & rB) +{ + return ! ( rB < rA ); +} + +/** + A character position. + + This is a wrapper to make the type for WW8 character position (CP) + distinct from WW8 file character positions (FC). +*/ +struct Cp +{ + sal_uInt32 nCp; // the WW8 character position + + Cp() : nCp(0) {} + + Cp(sal_uInt32 nCp_) : nCp(nCp_) {} + + /** + Returns the WW8 character position. + + @return the WW8 character position + */ + sal_uInt32 get() const { return nCp; } + + /** + Sets the WW8 character position. + + @param nCp_ the WW8 character position to set + */ + void set(sal_uInt32 nCp_) { nCp = nCp_; } + + /** + Calculate CP moved backward. + + None of the involved CPs is changed. + + @param n amount of movement + + @return CP moved @n steps backward + */ + sal_uInt32 operator - (const Cp & rCp) const + { return nCp - rCp.nCp; } + + /** + Calculate CP moved forward. + + None of the involved CPs is changed. + + @param n amount of movement + + @return CP moved @n steps forward + */ + Cp operator + (sal_uInt32 n) const + { return Cp(nCp + n); } + + /** + Advance CP forward. + + @attention The CP is altered. + + @param n amount of movement + + @return CP moved @n steps forward + */ + Cp & operator += (sal_uInt32 n) + { + nCp += n; + + return *this; + } + + /** + Return string representation of CP. + */ + string toString() const; + + friend bool operator < (const Cp & rA, const Cp & rB); + friend bool operator == (const Cp & rA, const Cp & rB); + friend ostream & operator << (ostream & o, const Cp & rCp); +}; + +/** + A file character position. + + This is a wrapper to make the type for WW8 character position (CP) + distinct from WW8 file character positions (FC). + + \see{Cp} +*/ +struct Fc +{ + sal_uInt32 mnFc; // the WW8 character position + bool mbComplex; + + Fc() : mnFc(0), mbComplex(false) {} + + Fc(sal_uInt32 nFc, bool bComplex = true) + : mnFc(nFc), mbComplex(bComplex) + {} + + sal_uInt32 complexFactor() const { return mbComplex ? 1 : 2; } + + /** + Returns the WW8 character position. + + @return the WW8 character position + */ + sal_uInt32 get() const { return mnFc; } + + /** + Sets the WW8 file character position. + + @param nFc the WW8 file character position to set + */ + void set(sal_uInt32 nFc) { mnFc = nFc; } + + /** + Set if the FC is complex. + + @param bComplex true if FC is set to be complex + */ + void setComplex(bool bComplex) { mbComplex = bComplex; } + + /** + Return if FC is complex. + + @retval true FC is complex + @retval false else + */ + bool isComplex() const { return mbComplex; } + + /** + Distance of FCs. + + None of the involved FCs is changed. + + @param rFc FC to calculate distance to + + @return Distance from @a rFc to this FC + */ + sal_uInt32 operator - (const Fc & rFc) const + { return (mnFc - rFc.mnFc) / complexFactor(); } + + /** + Calculate FC moved backward. + + None of the involved FCs is changed. + + @param n amount of movement + + @return FC moved @n steps backward + */ + Fc operator - (sal_uInt32 n) const + { return Fc(mnFc - n * complexFactor(), mbComplex); } + + /** + Calculate FC moved forward. + + None of the involved FCs is changed. + + @param n amount of movement + + @return FC moved @n steps Forward + */ + Fc operator + (sal_uInt32 n) const + { return Fc(mnFc + n * complexFactor(), mbComplex); } + + /** + Return string representation of FC. + */ + string toString() const; + + friend bool operator < (const Fc & rA, const Fc & rB); + friend bool operator == (const Fc & rA, const Fc & rB); + friend ostream & operator << (ostream & o, const Fc & rFc); +}; + +/** + A character position and a corresponding file character position + paired. + */ +class CpAndFc +{ +private: + /** + character position + */ + Cp mCp; + + /** + file character position + */ + Fc mFc; + + /** + property type + */ + PropertyType mType; + +public: + CpAndFc() {} + CpAndFc(const Cp & rCp, const Fc & rFc, PropertyType eType_); + + /** + Return character position. + */ + const Cp & getCp() const { return mCp; } + + /** + Return file character position. + */ + const Fc & getFc() const { return mFc; } + + /** + Return property type. + */ + PropertyType getType() const { return mType; } + + /** + Return if FC is complex. + + @retval true FC is complex + @retval false else + */ + bool isComplex() const { return mFc.isComplex(); } + + /** + Return the distance to other CpAndFc. + + @param rCpAndFc the other CpAndFc + + @return the distance from the CP in @a rCpAndFc to the CP in + CpAndFc. + */ + sal_uInt32 operator-(const CpAndFc & rCpAndFc) const + { return mCp - rCpAndFc.mCp; } + + /** + Return string representation of the CpAndFc. + */ + string toString() const; + + friend bool operator < (const CpAndFc & rA, const CpAndFc & rB); + friend bool operator == (const CpAndFc & rA, const CpAndFc & rB); + friend ostream & operator << (ostream & o, const CpAndFc & rCpAndFc); +}; + +struct CpAndFcLess +{ + CpAndFcLess() + { + } + + bool operator()(const CpAndFc & rA, const CpAndFc & rB) const + { + return rA < rB; + } + + bool operator()(const CpAndFc & rA, const Cp & rB) const + { + return rA.getCp() < rB; + } + + bool operator()(const Cp & rA, const CpAndFc & rB) const + { + return rA < rB.getCp(); + } +}; + + +typedef set<CpAndFc, CpAndFcLess> CpAndFcs; + +ostream & operator << (ostream & o, const CpAndFcs & rCpAndFcs); + +struct CpHash +{ + size_t operator()(const Cp & rCp) const + { + return rCp.get(); + } +}; + +struct FcHash +{ + size_t operator()(const Fc & rFc) const + { + return rFc.get(); + } +}; + +struct CpEq +{ + bool operator() (const Cp & rA, const Cp &rB) const + { + return rA == rB; + } +}; + +struct CpAndFcHash +{ + size_t operator()(const CpAndFc & rCpAndFc) const + { + CpHash aHash; + + return aHash(rCpAndFc.getCp()); + } +}; + +typedef hash_map<Cp, Fc, CpHash, CpEq> Cp2FcHashMap_t; + +} // namespace doctok +} // namespace writerfilter + +#endif // INCLUDED_WW8_CP_AND_FC_HXX diff --git a/writerfilter/source/doctok/WW8DocumentImpl.cxx b/writerfilter/source/doctok/WW8DocumentImpl.cxx new file mode 100644 index 000000000000..fee0abc85fe7 --- /dev/null +++ b/writerfilter/source/doctok/WW8DocumentImpl.cxx @@ -0,0 +1,2366 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resourcemodel/exceptions.hxx> +#include <resourcemodel/QNameToString.hxx> +#include <WW8DocumentImpl.hxx> +#include <WW8FKPImpl.hxx> +#include <WW8PieceTableImpl.hxx> +#include <WW8BinTableImpl.hxx> +#include <WW8StreamImpl.hxx> +#include <WW8Sttbf.hxx> +#include <Dff.hxx> +#include <iterator> +#include <XNoteHelperImpl.hxx> +#include <rtl/ustring.hxx> +#include <rtl/ustrbuf.hxx> +#include <doctokLoggers.hxx> + +namespace writerfilter { +namespace doctok +{ + +using namespace ::std; + +template <class T> +struct PLCFHelper +{ + static void processPLCFCpAndFcs(WW8DocumentImpl & rDoc, + WW8PieceTable::Pointer_t pPieceTable, + typename PLCF<T>::Pointer_t pPLCF, + PropertyType eType, + sal_uInt32 nOffset) + { + sal_uInt32 nCount = pPLCF->getEntryCount(); + for (sal_uInt32 n = 0; n < nCount; ++n) + { + Cp aCp(pPLCF->getFc(n) + nOffset); + CpAndFc aCpAndFc = pPieceTable->createCpAndFc(aCp, eType); + + rDoc.insertCpAndFc(aCpAndFc); + } + } +}; + +// WW8DocumentIteratorImpl +bool operator == (const WW8DocumentIterator & rA, + const WW8DocumentIterator & rB) +{ + return rA.equal(rB); +} + +WW8DocumentIterator::~WW8DocumentIterator() +{ +} + +WW8DocumentIteratorImpl::~WW8DocumentIteratorImpl() +{ +} + +WW8DocumentIterator & WW8DocumentIteratorImpl::operator++() +{ + mCpAndFc = mpDocument->getNextCp(mCpAndFc); + + return *this; +} + +WW8DocumentIterator & WW8DocumentIteratorImpl::operator--() +{ + mCpAndFc = mpDocument->getPrevCp(mCpAndFc); + + return *this; +} + +bool WW8DocumentIteratorImpl::equal(const WW8DocumentIterator & rIt_) const +{ + const WW8DocumentIteratorImpl & rIt = + dynamic_cast<const WW8DocumentIteratorImpl &>(rIt_); + + return mCpAndFc == rIt.mCpAndFc && mpDocument == rIt.mpDocument; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentIteratorImpl::getProperties() const +{ + return mpDocument->getProperties(mCpAndFc); +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentIteratorImpl::getSubDocument() const +{ + return mpDocument->getSubDocument(mCpAndFc); +} + +WW8SED * WW8DocumentIteratorImpl::getSED() const +{ + return mpDocument->getSED(mCpAndFc); +} + +WW8Stream::Sequence WW8DocumentIteratorImpl::getText() +{ + return mpDocument->getText(mCpAndFc); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentIteratorImpl::getShape() const +{ + return mpDocument->getShape(mCpAndFc); +} + +PropertyType WW8DocumentIteratorImpl::getPropertyType() const +{ + return mCpAndFc.getType(); +} + +bool WW8DocumentIteratorImpl::isComplex() const +{ + return mCpAndFc.isComplex(); +} + +void WW8DocumentIteratorImpl::dump(ostream & o) const +{ + o << mCpAndFc; +} + +string WW8DocumentIteratorImpl::toString() const +{ + return mCpAndFc.toString(); +} + +// WW8DocumentImpl + +WW8Document::~WW8Document() +{ +} + +#ifdef DEBUG +class WW8IdToString : public IdToString +{ +public: + WW8IdToString() : IdToString() {} + virtual ~WW8IdToString() {} + + virtual string toString(const Id & rId) const + { + string s((*SprmIdToString::Instance())(rId)); + + if (s.size() == 0) + s = (*QNameToString::Instance())(rId); + + return s; + } +}; +#endif + +WW8DocumentImpl::~WW8DocumentImpl() +{ +} + +WW8DocumentImpl::WW8DocumentImpl(WW8Stream::Pointer_t rpStream) +: bSubDocument(false), mfcPicLoc(0), mbPicIsData(false), mpStream(rpStream), +mbInSection(false), mbInParagraphGroup(false), mbInCharacterGroup(false) +{ + mpDocStream = getSubStream(::rtl::OUString::createFromAscii + ("WordDocument")); + + mpSummaryInformationStream = getSubStream(::rtl::OUString::createFromAscii + ("\5SummaryInformation")); + + try + { + mpDataStream = getSubStream(::rtl::OUString::createFromAscii + ("Data")); + } + catch (ExceptionNotFound e) + { + } + + try + { + mpCompObjStream = getSubStream(::rtl::OUString::createFromAscii + ("\1CompObj")); + } + catch (ExceptionNotFound e) + { + } + + mpCHPFKPCache = + WW8FKPCache::Pointer_t(new WW8CHPFKPCacheImpl(mpDocStream, 5)); + mpPAPFKPCache = + WW8FKPCache::Pointer_t(new WW8PAPFKPCacheImpl(mpDocStream, 5)); + + mpFib = WW8Fib::Pointer_t(new WW8Fib(*mpDocStream)); + + switch (mpFib->get_fWhichTblStm()) + { + case 0: + mpTableStream = getSubStream(::rtl::OUString::createFromAscii + ("0Table")); + + break; + + case 1: + mpTableStream = getSubStream(::rtl::OUString::createFromAscii + ("1Table")); + + break; + + default: + break; + } + + if (mpFib->get_nFib() >= 0xD9) + { + mpFibRgFcLcb2000.reset(new WW8FibRgFcLcb2000(*mpFib)); + } + + if (mpTableStream.get() == NULL) + throw ExceptionNotFound("Table stream not found."); + + mpPieceTable = + WW8PieceTable::Pointer_t + (new WW8PieceTableImpl(*mpTableStream, mpFib->get_fcClx(), + mpFib->get_lcbClx())); + + { + Cp aCp(mpPieceTable->getLastCp()); + Fc aFc(mpPieceTable->getLastFc()); + CpAndFc aCpAndFc(aCp, aFc, PROP_DOC); + mCpAndFcs.insert(aCpAndFc); + } + + { + Cp aCp(mpFib->get_ccpText()); + + mDocumentEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mDocumentEndCpAndFc); + + aCp += mpFib->get_ccpFtn(); + mFootnoteEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mFootnoteEndCpAndFc); + + aCp += mpFib->get_ccpHdd(); + mHeaderEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mHeaderEndCpAndFc); + + aCp += mpFib->get_ccpAtn(); + mAnnotationEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mAnnotationEndCpAndFc); + + aCp += mpFib->get_ccpEdn(); + mEndnoteEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mEndnoteEndCpAndFc); + + aCp += mpFib->get_ccpTxbx(); + mTextboxEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mTextboxEndCpAndFc); + + aCp += mpFib->get_ccpHdrTxbx(); + mTextboxHeaderEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp), + PROP_DOC); + mCpAndFcs.insert(mTextboxHeaderEndCpAndFc); + } + + mpBinTablePAPX = + WW8BinTable::Pointer_t(new WW8BinTableImpl + (*mpTableStream, + mpFib->get_fcPlcfbtePapx(), + mpFib->get_lcbPlcfbtePapx())); + + //clog << "BinTable(PAP):" << mpBinTablePAPX->toString(); + + parseBinTableCpAndFcs(*mpBinTablePAPX, PROP_PAP); + + mpBinTableCHPX = + WW8BinTable::Pointer_t(new WW8BinTableImpl + (*mpTableStream, + mpFib->get_fcPlcfbteChpx(), + mpFib->get_lcbPlcfbteChpx())); + + //clog << "BinTable(CHP):" << mpBinTableCHPX->toString(); + + parseBinTableCpAndFcs(*mpBinTableCHPX, PROP_CHP); + + mpSEDs = PLCF<WW8SED>::Pointer_t(new PLCF<WW8SED> + (*mpTableStream, + mpFib->get_fcPlcfsed(), + mpFib->get_lcbPlcfsed())); + + //mpSEDs->dump(clog); + + { + PLCFHelper<WW8SED>::processPLCFCpAndFcs + (*this, mpPieceTable, mpSEDs, PROP_SEC, 0); + } + + sal_uInt32 nHeaders = getHeaderCount(); + + if (nHeaders > 0) + { + mpHeaderOffsets = WW8StructBase::Pointer_t + (new WW8StructBase(*mpTableStream, + mpFib->get_fcPlcfhdd(), + mpFib->get_lcbPlcfhdd())); + + { + for (sal_uInt32 n = 0; n <= nHeaders; ++n) + { + CpAndFc aCpAndFc(getHeaderCpAndFc(n)); + + mCpAndFcs.insert(aCpAndFc); + } + } + } + + if (mpFib->get_lcbPlcffndTxt() > 0) + { + WW8StructBase::Pointer_t pCps + (new WW8StructBase(*mpTableStream, + mpFib->get_fcPlcffndTxt(), + mpFib->get_lcbPlcffndTxt())); + + PLCF<WW8FRD>::Pointer_t pRefs + (new PLCF<WW8FRD>(*mpTableStream, + mpFib->get_fcPlcffndRef(), + mpFib->get_lcbPlcffndRef())); + + mpFootnoteHelper = XNoteHelper<WW8FRD>::Pointer_t + (new XNoteHelper<WW8FRD>(pCps, pRefs, mpPieceTable, this, + PROP_FOOTNOTE, getDocumentEndCp())); + + mpFootnoteHelper->init(); + } + + if (mpFib->get_lcbPlcfendTxt() > 0) + { + WW8StructBase::Pointer_t pCps + (new WW8StructBase(*mpTableStream, + mpFib->get_fcPlcfendTxt(), + mpFib->get_lcbPlcfendTxt())); + + PLCF<WW8FRD>::Pointer_t pRefs + (new PLCF<WW8FRD>(*mpTableStream, + mpFib->get_fcPlcfendRef(), + mpFib->get_lcbPlcfendRef())); + + mpEndnoteHelper = XNoteHelper<WW8FRD>::Pointer_t + (new XNoteHelper<WW8FRD>(pCps, pRefs, mpPieceTable, this, + PROP_ENDNOTE, getAnnotationEndCp())); + + mpEndnoteHelper->init(); + } + + if (mpFib->get_lcbPlcfandTxt() > 0) + { + WW8StructBase::Pointer_t pCps + (new WW8StructBase(*mpTableStream, + mpFib->get_fcPlcfandTxt(), + mpFib->get_lcbPlcfandTxt())); + + PLCF<WW8ATRD>::Pointer_t pRefs + (new PLCF<WW8ATRD>(*mpTableStream, + mpFib->get_fcPlcfandRef(), + mpFib->get_lcbPlcfandRef())); + + mpAnnotationHelper = XNoteHelper<WW8ATRD>::Pointer_t + (new XNoteHelper<WW8ATRD>(pCps, pRefs, mpPieceTable, this, + PROP_ANNOTATION, getHeaderEndCp())); + + mpAnnotationHelper->init(); + } + + if (mpFib->get_lcbSttbfbkmk() > 0) + { + PLCF<WW8BKF>::Pointer_t pStartCps + (new PLCF<WW8BKF>(*mpTableStream, mpFib->get_fcPlcfbkf(), + mpFib->get_lcbPlcfbkf())); + + WW8StructBase::Pointer_t pEndCps + (new WW8StructBase(*mpTableStream, mpFib->get_fcPlcfbkl(), + mpFib->get_lcbPlcfbkl())); + + WW8Sttbf::Pointer_t pNames + (new WW8Sttbf(*mpTableStream, mpFib->get_fcSttbfbkmk(), + mpFib->get_lcbSttbfbkmk())); + + mpBookmarkHelper = BookmarkHelper::Pointer_t + (new BookmarkHelper(pStartCps, pEndCps, pNames, mpPieceTable, this)); + + mpBookmarkHelper->init(); + } + + { + PLCF<WW8FLD>::Pointer_t pPlcffldMom; + + if (mpFib->get_lcbPlcffldMom() > 0) + { + pPlcffldMom = PLCF<WW8FLD>::Pointer_t + (new PLCF<WW8FLD>(*mpTableStream, + mpFib->get_fcPlcffldMom(), + mpFib->get_lcbPlcffldMom())); + + mpFieldHelper = FieldHelper::Pointer_t + (new FieldHelper(pPlcffldMom, + this)); + + mpFieldHelper->init(); + } + } + + PLCF<WW8FSPA>::Pointer_t pPlcspaMom; + if (mpFib->get_lcbPlcspaMom() > 0) + { + pPlcspaMom = PLCF<WW8FSPA>::Pointer_t + (new PLCF<WW8FSPA> + (*mpTableStream, mpFib->get_fcPlcspaMom(), + mpFib->get_lcbPlcspaMom())); + } + + PLCF<WW8FSPA>::Pointer_t pPlcspaHdr; + if (mpFib->get_lcbPlcspaHdr() > 0) + { + pPlcspaHdr = PLCF<WW8FSPA>::Pointer_t + (new PLCF<WW8FSPA> + (*mpTableStream, mpFib->get_fcPlcspaHdr(), + mpFib->get_lcbPlcspaHdr())); + } + + mpShapeHelper = ShapeHelper::Pointer_t + (new ShapeHelper(pPlcspaMom, pPlcspaHdr, this)); + + mpShapeHelper->init(); + + PLCF<WW8BKD>::Pointer_t pPlcbkdMother; + if (mpFib->get_fcBkdMother() > 0 && mpFib->get_lcbBkdMother() > 0) + { + pPlcbkdMother = PLCF<WW8BKD>::Pointer_t + (new PLCF<WW8BKD> + (*mpTableStream, mpFib->get_fcBkdMother(), + mpFib->get_lcbBkdMother())); + } + + mpBreakHelper = BreakHelper::Pointer_t + (new BreakHelper(pPlcbkdMother, this)); + + mpBreakHelper->init(); + + if (mpFib->get_fcDggInfo() != 0 && mpFib->get_lcbDggInfo() > 0) + { + mpDffBlock = DffBlock::Pointer_t + (new DffBlock(*mpTableStream, mpFib->get_fcDggInfo(), + mpFib->get_lcbDggInfo(), 1)); + + mpDffBlock->setDocument(this); + } + + if (mpFib->get_lcbPlcftxbxTxt() > 0) + { + mpTextBoxStories = PLCF<WW8FTXBXS>::Pointer_t + (new PLCF<WW8FTXBXS>(*mpTableStream, + mpFib->get_fcPlcftxbxTxt(), + mpFib->get_lcbPlcftxbxTxt())); + + PLCFHelper<WW8FTXBXS>::processPLCFCpAndFcs + (*this, mpPieceTable, mpTextBoxStories, PROP_DOC, + mEndnoteEndCpAndFc.getCp().get()); + } + + if (mCpAndFcs.size() > 0) + { + mCpAndFcStart = *mCpAndFcs.begin(); + mCpAndFcEnd = getDocumentEndCp(); + } +} + +bool WW8DocumentImpl::isSpecial(sal_uInt32 nChar) +{ + bool bResult = false; + + if (nChar <= 8) + bResult = true; + else if (nChar >= 10) + { + if (nChar == 12) + bResult= true; + else if (nChar <= 16) + bResult = true; + else if (nChar >= 22) + { + if (nChar <= 30) + bResult = true; + else if (nChar >= 33) + { + if (nChar <= 39) + bResult = true; + else if (nChar == 41) + bResult = true; + } + } + } + + return bResult; +} + +WW8DocumentImpl::WW8DocumentImpl(const WW8DocumentImpl & rSrc, + const CpAndFc & rStart, const CpAndFc & rEnd) +: bSubDocument(true), mfcPicLoc(0), mbPicIsData(false) +{ + Assign(rSrc); + + mCpAndFcStart = rStart; + mCpAndFcEnd = rEnd; +} + +WW8DocumentImpl & WW8DocumentImpl::Assign(const WW8DocumentImpl & rSrc) +{ + mCpAndFcs = rSrc.mCpAndFcs; + + mpCHPFKPCache = rSrc.mpCHPFKPCache; + mpPAPFKPCache = rSrc.mpPAPFKPCache; + + mpStream = rSrc.mpStream; + mpTableStream = rSrc.mpTableStream; + mpDataStream = rSrc.mpDataStream; + mpDocStream = rSrc.mpDocStream; + mpCompObjStream = rSrc.mpCompObjStream; + + mpPieceTable = rSrc.mpPieceTable; + + mpBinTableCHPX = rSrc.mpBinTableCHPX; + mpBinTablePAPX = rSrc.mpBinTablePAPX; + + mpSEDs = rSrc.mpSEDs; + + mpFib = rSrc.mpFib; + + mpHeaderOffsets = rSrc.mpHeaderOffsets; + mpFootnoteHelper = rSrc.mpFootnoteHelper; + mpEndnoteHelper = rSrc.mpEndnoteHelper; + mpAnnotationHelper = rSrc.mpAnnotationHelper; + mpShapeHelper = rSrc.mpShapeHelper; + mpBreakHelper = rSrc.mpBreakHelper; + + mpBookmarkHelper = rSrc.mpBookmarkHelper; + + mpDffBlock = rSrc.mpDffBlock; + mpTextBoxStories = rSrc.mpTextBoxStories; + + mDocumentEndCpAndFc = rSrc.mDocumentEndCpAndFc; + mFootnoteEndCpAndFc = rSrc.mFootnoteEndCpAndFc; + + return *this; +} + +string WW8DocumentImpl::getType() const +{ + return "WW8DocumentImpl"; +} + +void WW8DocumentImpl::parseBinTableCpAndFcs(WW8BinTable & rTable, + PropertyType eType_) +{ + //clog << "<bintable type=\"" << propertyTypeToString(eType_) << "\">" << endl; + for (sal_uInt32 i = 0; i < rTable.getEntryCount(); i++) + { +#if 0 + char sBuffer[255]; + snprintf(sBuffer, 255, "%ld", i); + char sBufferPageNum[255]; + snprintf(sBufferPageNum, 255, "%ld", rTable.getPageNumber(i)); +#endif + Fc aFcFromTable(rTable.getFc(i)); + + if (aFcFromTable < mpPieceTable->getFirstFc()) + aFcFromTable = mpPieceTable->getFirstFc(); + + bool bComplex = mpPieceTable->isComplex(aFcFromTable); + aFcFromTable.setComplex(bComplex); + + //clog << "<entry fc=\"" << aFcFromTable.toString() << "\">" << endl; + + try + { + Cp aCpFromTable(mpPieceTable->fc2cp(aFcFromTable)); + CpAndFc aCpAndFcFromTable(aCpFromTable, aFcFromTable, eType_); + + mCpAndFcs.insert(aCpAndFcFromTable); + + WW8FKP::Pointer_t pFKP; + + switch (eType_) + { + case PROP_CHP: + pFKP = getFKPCHPX(rTable.getPageNumber(i), + aCpAndFcFromTable.isComplex()); + + break; + + case PROP_PAP: + pFKP = getFKPPAPX(rTable.getPageNumber(i), + aCpAndFcFromTable.isComplex()); + + break; + default: + break; + } + + for (sal_uInt32 n = 0; n < pFKP->getEntryCount(); n++) + { + Fc aFc = pFKP->getFc(n); + + if (aFc < mpPieceTable->getFirstFc()) + aFc = mpPieceTable->getFirstFc(); + + bool bComplexFKP = mpPieceTable->isComplex(aFc); + aFc.setComplex(bComplexFKP); + + //clog << "<fkpentry fc=\"" << aFc.toString() << "\"/>" << endl; + + try + { + Cp aCp = mpPieceTable->fc2cp(aFc); + + CpAndFc aCpAndFc(aCp, aFc, eType_); + + mCpAndFcs.insert(aCpAndFc); + + //clog << aCpAndFc << endl; + } + catch (ExceptionNotFound e) + { + clog << e.getText() << endl; + } + } + } + catch (ExceptionNotFound e) + { + clog << e.getText() << endl; + } + + //clog << "</entry>" << endl; + } + + //clog << "</bintable>" << endl; +} + +WW8Stream::Pointer_t WW8DocumentImpl::getSubStream +(const ::rtl::OUString & sId) const +{ + return mpStream->getSubStream(sId); +} + +WW8Document::Pointer_t WW8DocumentImpl::getSubDocument(SubDocumentId /*nId*/) +{ + return WW8Document::Pointer_t(new WW8DocumentImpl(*this)); +} + +WW8DocumentIterator::Pointer_t +WW8DocumentImpl::getIterator(const CpAndFc & rCpAndFc) +{ + return WW8DocumentIterator::Pointer_t + (new WW8DocumentIteratorImpl(this, rCpAndFc)); +} + +WW8DocumentIterator::Pointer_t WW8DocumentImpl::begin() +{ + return getIterator(getFirstCp()); +} + +WW8DocumentIterator::Pointer_t WW8DocumentImpl::end() +{ + return getIterator(getLastCp()); +} + +WW8Stream::Pointer_t WW8DocumentImpl::getDocStream() const +{ + return mpDocStream; +} + +WW8Stream::Pointer_t WW8DocumentImpl::getDataStream() const +{ + return mpDataStream; +} + +sal_uInt32 WW8DocumentImpl::getByteLength(const CpAndFc & rCpAndFc) const +{ + CpAndFc aEnd = getNextCp(rCpAndFc); + + sal_uInt32 nResult = 3; + + if (rCpAndFc < aEnd) + nResult = (aEnd - rCpAndFc) * + (mpPieceTable->isComplex(rCpAndFc.getCp()) ? 1 : 2); + + return nResult; +} + +WW8Stream::Sequence +WW8DocumentImpl::getText(const CpAndFc & rStart) +{ + return mpDocStream->get(rStart.getFc().get(), getByteLength(rStart)); +} + +const CpAndFc & WW8DocumentImpl::getFirstCp() const +{ + return mCpAndFcStart; +} + +const CpAndFc & WW8DocumentImpl::getLastCp() const +{ + return mCpAndFcEnd; +} + +CpAndFc WW8DocumentImpl::getDocumentEndCp() const +{ + return mDocumentEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getFootnodeEndCp() const +{ + return mFootnoteEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getHeaderEndCp() const +{ + return mHeaderEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getAnnotationEndCp() const +{ + return mAnnotationEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getEndnoteEndCp() const +{ + return mEndnoteEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getTextboxEndCp() const +{ + return mTextboxEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getTextboxHeaderEndCp() const +{ + return mTextboxHeaderEndCpAndFc; +} + +CpAndFc WW8DocumentImpl::getNextCp(const CpAndFc & rCpAndFc) const +{ + CpAndFc aResult = mCpAndFcEnd; + CpAndFcs::const_iterator aIt = mCpAndFcs.find(rCpAndFc); + + if (aIt != mCpAndFcs.end()) + { + aIt++; + + if (aIt != mCpAndFcs.end()) + aResult = *aIt; + } + else + throw ExceptionNotFound("getNextCp: " + rCpAndFc.toString()); + + return aResult; +} + +CpAndFc WW8DocumentImpl::getPrevCp(const CpAndFc & rCpAndFc) const +{ + CpAndFc aResult = mCpAndFcStart; + + CpAndFcs::const_iterator aIt = mCpAndFcs.find(CpAndFc(rCpAndFc)); + + if (aIt != mCpAndFcs.end() && aIt != mCpAndFcs.begin()) + { + aIt--; + + aResult = *aIt; + } + else + throw ExceptionNotFound("getPrevCp: " + rCpAndFc.toString()); + + return aResult; +} + +WW8FKP::Pointer_t WW8DocumentImpl::getFKP(const CpAndFc & rCpAndFc) +{ + WW8FKP::Pointer_t pResult; + + sal_uInt32 nPageNumber = 0; + + switch (rCpAndFc.getType()) + { + case PROP_PAP: + { + nPageNumber = + mpBinTablePAPX->getPageNumber(rCpAndFc.getFc()); + + pResult = getFKPPAPX(nPageNumber, rCpAndFc.isComplex()); + } + break; + case PROP_CHP: + { + nPageNumber = + mpBinTableCHPX->getPageNumber(rCpAndFc.getFc()); + + pResult = getFKPCHPX(nPageNumber, rCpAndFc.isComplex()); + } + break; + default: + break; + } + + if (pResult.get() != NULL) + pResult->setDocument(this); + + return pResult; +} + +WW8FKP::Pointer_t WW8DocumentImpl::getFKPCHPX(sal_uInt32 nIndex, + bool bComplex) +{ + return mpCHPFKPCache->get(nIndex, bComplex); +} + +WW8FKP::Pointer_t WW8DocumentImpl::getFKPPAPX(sal_uInt32 nIndex, + bool bComplex) +{ + return mpPAPFKPCache->get(nIndex, bComplex); +} + +writerfilter::Reference<Properties>::Pointer_t WW8DocumentImpl::getProperties +(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + switch (rCpAndFc.getType()) + { + case PROP_CHP: + case PROP_PAP: + { + try + { + WW8FKP::Pointer_t pFKP = getFKP(rCpAndFc); + + pResult = pFKP->getProperties(rCpAndFc.getFc()); + } + catch (ExceptionOutOfBounds e) + { + } + } + + break; + + case PROP_SEC: + { + pResult = writerfilter::Reference<Properties>::Pointer_t + (getSED(rCpAndFc)); + } + + break; + + case PROP_FOOTNOTE: + { + pResult = writerfilter::Reference<Properties>::Pointer_t + (mpFootnoteHelper->getRef(rCpAndFc)); + } + break; + + case PROP_ENDNOTE: + { + pResult = writerfilter::Reference<Properties>::Pointer_t + (mpEndnoteHelper->getRef(rCpAndFc)); + } + break; + + case PROP_ANNOTATION: + { + pResult = writerfilter::Reference<Properties>::Pointer_t + (mpAnnotationHelper->getRef(rCpAndFc)); + } + break; + + case PROP_BOOKMARKSTART: + case PROP_BOOKMARKEND: + { + pResult = getBookmark(rCpAndFc); + } + + break; + case PROP_FLD: + { + pResult = getField(rCpAndFc); + + mpFLD = mpFieldHelper->getWW8FLD(rCpAndFc); + } + + break; + case PROP_SHP: + { + pResult = getShape(rCpAndFc); + } + break; + case PROP_BRK: + { + pResult = getBreak(rCpAndFc); + } + break; + default: + break; + } + + return pResult; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getSubDocument(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + switch (rCpAndFc.getType()) + { + case PROP_FOOTNOTE: + pResult = getFootnote(rCpAndFc); + break; + + case PROP_ENDNOTE: + pResult = getEndnote(rCpAndFc); + break; + + case PROP_ANNOTATION: + pResult = getAnnotation(rCpAndFc); + break; + + default: + break; + } + + return pResult; +} + +WW8SED * WW8DocumentImpl::getSED(const CpAndFc & rCpAndFc) const +{ + WW8SED * pResult = mpSEDs->getEntryByFc(rCpAndFc.getCp().get()); + + pResult->setDoc(const_cast<const WW8DocumentImpl *>(this)); + + return pResult; +} + +writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getListTplcs() const +{ + writerfilter::Reference<Table>::Pointer_t pResult; + + if (mpFibRgFcLcb2000.get() != NULL && + mpFibRgFcLcb2000->get_fcSttbRgtplc() != 0 && + mpFibRgFcLcb2000->get_lcbSttbRgtplc() != 0) + { + WW8SttbRgtplc * pSttbRgtplc = + new WW8SttbRgtplc(*mpTableStream, + mpFibRgFcLcb2000->get_fcSttbRgtplc(), + mpFibRgFcLcb2000->get_lcbSttbRgtplc()); + + pResult = writerfilter::Reference<Table>::Pointer_t(pSttbRgtplc); + } + + return pResult; +} + +writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getListTable() const +{ + writerfilter::Reference<Table>::Pointer_t pResult; + + if (mpFib->get_fcPlcfLst() != 0 && mpFib->get_lcbPlcfLst() > 0) + { + try + { + WW8ListTable * pList = new WW8ListTable(*mpTableStream, + mpFib->get_fcPlcfLst(), + mpFib->get_fcPlfLfo() - + mpFib->get_fcPlcfLst()); + + pList->setPayloadOffset(mpFib->get_lcbPlcfLst()); + pList->initPayload(); + + pResult = writerfilter::Reference<Table>::Pointer_t(pList); + } + catch (ExceptionOutOfBounds aException) { + } + } + + return pResult; +} + +writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getLFOTable() const +{ + writerfilter::Reference<Table>::Pointer_t pResult; + + if (mpFib->get_fcPlfLfo() != 0 && mpFib->get_lcbPlfLfo() > 0) + { + try + { + WW8LFOTable * pLFOs = new WW8LFOTable(*mpTableStream, + mpFib->get_fcPlfLfo(), + mpFib->get_lcbPlfLfo()); + + pLFOs->setPayloadOffset(mpFib->get_lcbPlcfLst()); + pLFOs->initPayload(); + + pResult = writerfilter::Reference<Table>::Pointer_t(pLFOs); + } + catch (Exception e) + { + clog << e.getText() << endl; + } + } + + return pResult; +} + +writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getFontTable() const +{ + writerfilter::Reference<Table>::Pointer_t pResult; + + if (mpFib->get_fcSttbfffn() != 0 && mpFib->get_lcbSttbfffn() > 0) + { + WW8FontTable * pFonts = new WW8FontTable(*mpTableStream, + mpFib->get_fcSttbfffn(), + mpFib->get_lcbSttbfffn()); + + pFonts->initPayload(); + + pResult = writerfilter::Reference<Table>::Pointer_t(pFonts); + } + + return pResult; +} + +writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getStyleSheet() const +{ + writerfilter::Reference<Table>::Pointer_t pResult; + + if (mpFib->get_lcbStshf() > 0) + { + WW8StyleSheet * pStyles = new WW8StyleSheet(*mpTableStream, + mpFib->get_fcStshf(), + mpFib->get_lcbStshf()); + + pStyles->initPayload(); + + pResult = writerfilter::Reference<Table>::Pointer_t(pStyles); + } + + return pResult; +} + +writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getAssocTable() const +{ + writerfilter::Reference<Table>::Pointer_t pResult; + + if (mpFib->get_lcbSttbfAssoc() > 0) + { + WW8Sttbf::Pointer_t pSttbfAssoc + (new WW8Sttbf(*mpTableStream, + mpFib->get_fcSttbfAssoc(), + mpFib->get_lcbSttbfAssoc())); + + pResult = writerfilter::Reference<Table>::Pointer_t + (new WW8SttbTableResource(pSttbfAssoc)); + } + + return pResult; +} + +sal_uInt32 WW8DocumentImpl::getHeaderCount() const +{ + sal_uInt32 nResult = 0; + sal_uInt32 nLcbPlcfhdd = mpFib->get_lcbPlcfhdd(); + + if (nLcbPlcfhdd > 4) + nResult = (nLcbPlcfhdd / 4) - 1; + + return nResult; +} + +CpAndFc WW8DocumentImpl::getHeaderCpAndFc(sal_uInt32 nPos) +{ + sal_uInt32 nCount = getHeaderCount(); + + // There are getHeaderCount() + 1 entries in mpHeaderOffsets => greater + if (nPos > nCount) + throw ExceptionNotFound("getHeaderCpAndFc"); + + if (nPos == nCount) + return mHeaderEndCpAndFc; + else + { + Cp aCp(getFootnodeEndCp().getCp() + mpHeaderOffsets->getU32(nPos * 4)); + Fc aFc(mpPieceTable->cp2fc(aCp)); + CpAndFc aCpAndFc(aCp, aFc, PROP_DOC); + + return aCpAndFc; + } + +} + +writerfilter::Reference<Stream>::Pointer_t WW8DocumentImpl::getHeader(sal_uInt32 nPos) +{ + // There are getHeaderCount() headers => greater or equal + if (nPos >= getHeaderCount()) + throw ExceptionNotFound("getHeader"); + + writerfilter::Reference<Stream>::Pointer_t pResult; + + CpAndFc aCpAndFcStart(getHeaderCpAndFc(nPos)); + CpAndFc aCpAndFcEnd(getHeaderCpAndFc(nPos + 1)); + +#if 0 + sal_uInt32 nEquals = 1; + while (aCpAndFcEnd == aCpAndFcStart && nPos + nEquals < getHeaderCount()) + { + ++nEquals; + + aCpAndFcEnd = getHeaderCpAndFc(nPos + nEquals); + } +#endif + + if (aCpAndFcStart < aCpAndFcEnd) + pResult = writerfilter::Reference<Stream>::Pointer_t + (new WW8DocumentImpl(*this, aCpAndFcStart, aCpAndFcEnd)); + + return pResult; +} + +sal_uInt32 WW8DocumentImpl::getFootnoteCount() const +{ + return (mpFootnoteHelper.get() != NULL) ? mpFootnoteHelper->getCount() : 0; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getFootnote(sal_uInt32 nPos) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (! bSubDocument) + pResult = mpFootnoteHelper->get(nPos); + + return pResult; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getFootnote(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (! bSubDocument) + pResult = mpFootnoteHelper->get(rCpAndFc); + + return pResult; +} + +sal_uInt32 WW8DocumentImpl::getEndnoteCount() const +{ + return mpEndnoteHelper.get() != NULL ? mpEndnoteHelper->getCount() : 0; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getEndnote(sal_uInt32 nPos) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (! bSubDocument) + pResult = mpEndnoteHelper->get(nPos); + + return pResult; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getEndnote(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (! bSubDocument) + pResult = mpEndnoteHelper->get(rCpAndFc); + + return pResult; +} + +sal_uInt32 WW8DocumentImpl::getAnnotationCount() const +{ + return mpAnnotationHelper.get() != NULL ? + mpAnnotationHelper->getCount() : 0; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getAnnotation(sal_uInt32 nPos) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (! bSubDocument) + pResult = mpAnnotationHelper->get(nPos); + + return pResult; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getAnnotation(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (! bSubDocument) + pResult = mpAnnotationHelper->get(rCpAndFc); + + return pResult; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getBookmark(const CpAndFc & rCpAndFc) const +{ + return mpBookmarkHelper->getBookmark(rCpAndFc); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getShape(const CpAndFc & rCpAndFc) const +{ + return mpShapeHelper->getShape(rCpAndFc); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getShape(sal_uInt32 nSpid) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + DffRecord::Pointer_t pShape = mpDffBlock->getShape(nSpid); + + if (pShape.get() != NULL) + { + DffSpContainer * pTmp = new DffSpContainer(*pShape); + pTmp->setDocument(this); + + pResult = writerfilter::Reference<Properties>::Pointer_t(pTmp); + } + + return pResult; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getBreak(const CpAndFc & rCpAndFc) const +{ + return mpBreakHelper->getBreak(rCpAndFc); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getBlip(sal_uInt32 nBid) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + if (mpDffBlock != NULL) + { + DffRecord::Pointer_t pDffRecord(mpDffBlock->getBlip(nBid)); + + if (pDffRecord.get() != NULL) + { + DffBSE * pBlip = new DffBSE(*pDffRecord); + + if (pBlip != NULL) + pResult = writerfilter::Reference<Properties>::Pointer_t(pBlip); + } + } + + return pResult; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getField(const CpAndFc & rCpAndFc) const +{ + return mpFieldHelper->getField(rCpAndFc); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8DocumentImpl::getDocumentProperties() const +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + if (mpFib->get_lcbDop() > 0) + { + pResult.reset(new WW8DopBase(*mpTableStream, mpFib->get_fcDop(), mpFib->get_lcbDop())); + } + + return pResult; +} + +WW8FLD::Pointer_t WW8DocumentImpl::getCurrentFLD() const +{ + return mpFLD; +} + +sal_uInt32 WW8DocumentImpl::getPicLocation() const +{ + return mfcPicLoc; +} + +void WW8DocumentImpl::setPicLocation(sal_uInt32 fcPicLoc) +{ + mfcPicLoc = fcPicLoc; +} + +bool WW8DocumentImpl::isPicData() +{ + return mbPicIsData; +} + +void WW8DocumentImpl::setPicIsData(bool bPicIsData) +{ + mbPicIsData = bPicIsData; +} + +writerfilter::Reference<Stream>::Pointer_t +WW8DocumentImpl::getTextboxText(sal_uInt32 nShpId) const +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + if (mpTextBoxStories.get() != NULL) + { + sal_uInt32 nCount = mpTextBoxStories->getEntryCount(); + + sal_uInt32 n = 0; + while (n < nCount) + { + WW8FTXBXS * pTextboxStory = mpTextBoxStories->getEntryPointer(n); + + if (pTextboxStory->get_lid() == nShpId) + break; + + ++n; + } + + if (n < nCount) + { + Cp aCpStart(mpTextBoxStories->getFc(n)); + aCpStart += getEndnoteEndCp().getCp().get(); + CpAndFc aCpAndFcStart = + mpPieceTable->createCpAndFc(aCpStart, PROP_DOC); + Cp aCpEnd(mpTextBoxStories->getFc(n + 1)); + aCpEnd += getEndnoteEndCp().getCp().get(); + CpAndFc aCpAndFcEnd = mpPieceTable->createCpAndFc(aCpEnd, PROP_DOC); + + pResult = writerfilter::Reference<Stream>::Pointer_t + (new WW8DocumentImpl(*this, aCpAndFcStart, aCpAndFcEnd)); + } + } + + return pResult; +} + +Id lcl_headerQName(sal_uInt32 nIndex) +{ + Id qName = NS_rtf::LN_header; + + if (nIndex > 5) + { + switch ((nIndex - 6) % 6) + { + case 0: + qName = NS_rtf::LN_headerl; + + break; + case 1: + qName = NS_rtf::LN_headerr; + + break; + case 2: + qName = NS_rtf::LN_footerl; + + break; + case 3: + qName = NS_rtf::LN_footerr; + + break; + case 4: + qName = NS_rtf::LN_headerf; + + break; + case 5: + qName = NS_rtf::LN_footerf; + + break; + } + } + + return qName; +} + +Fc WW8DocumentImpl::cp2fc(const Cp & cp) const +{ + return mpPieceTable->cp2fc(cp); +} + +Cp WW8DocumentImpl::fc2cp(const Fc & fc) const +{ + return mpPieceTable->fc2cp(fc); +} + +CpAndFc WW8DocumentImpl::getCpAndFc(const Cp & cp, PropertyType type) const +{ + Fc aFc = cp2fc(cp); + + return CpAndFc(cp, aFc, type); +} + +CpAndFc WW8DocumentImpl::getCpAndFc(const Fc & fc, PropertyType type) const +{ + Cp aCp = fc2cp(fc); + + return CpAndFc(aCp, fc, type); +} + +void WW8DocumentImpl::resolvePicture(Stream & rStream) +{ + WW8Stream::Pointer_t pStream = getDataStream(); + + if (pStream.get() != NULL) + { + WW8StructBase aStruct(*pStream, mfcPicLoc, 4); + sal_uInt32 nCount = aStruct.getU32(0); + + { + WW8PICF * pPicf = new WW8PICF(*pStream, mfcPicLoc, nCount); + pPicf->setDocument(this); + + writerfilter::Reference<Properties>::Pointer_t pProps(pPicf); + + rStream.props(pProps); + } + } +} + +void WW8DocumentImpl::resolveSpecialChar(sal_uInt32 nChar, Stream & rStream) +{ + switch (nChar) + { + case 0x1: + resolvePicture(rStream); + break; + default: + break; + } +} + +void WW8DocumentImpl::text(Stream & rStream, const sal_uInt8 * data, size_t len) +{ +#ifdef DEBUG_ELEMENT + ::rtl::OUString sText( (const sal_Char*) data, len, RTL_TEXTENCODING_MS_1252 ); + debug_logger->startElement("text"); + debug_logger->chars(OUStringToOString(sText, RTL_TEXTENCODING_ASCII_US).getStr()); + debug_logger->endElement("text"); +#endif + rStream.text(data, len); +} + +void WW8DocumentImpl::utext(Stream & rStream, const sal_uInt8 * data, size_t len) +{ +#ifdef DEBUG_ELEMENT + debug_logger->startElement("utext"); + + ::rtl::OUString sText; + ::rtl::OUStringBuffer aBuffer = ::rtl:: OUStringBuffer(len); + aBuffer.append( (const sal_Unicode *) data, len); + sText = aBuffer.makeStringAndClear(); + + debug_logger->chars(OUStringToOString(sText, RTL_TEXTENCODING_ASCII_US).getStr()); + debug_logger->endElement("utext"); +#endif + rStream.utext(data, len); +} + + +void WW8DocumentImpl::resolveText(WW8DocumentIterator::Pointer_t pIt, + Stream & rStream) +{ + WW8Stream::Sequence aSeq = pIt->getText(); + + sal_uInt32 nCount = aSeq.getCount(); + bool bComplex = pIt->isComplex(); + + /* + Assumption: Special characters are always at the beginning or end of a + run. + */ + if (nCount > 0) + { + if (nCount == 1) + bComplex = true; + + if (bComplex) + { + sal_uInt32 nStartIndex = 0; + sal_uInt32 nEndIndex = nCount - 1; + + sal_uInt32 nCharFirst = aSeq[0]; + sal_uInt32 nCharLast = aSeq[nEndIndex]; + + if (isSpecial(nCharFirst)) + { + nStartIndex += 1; + resolveSpecialChar(nCharFirst, rStream); + text(rStream, &aSeq[0], 1); + } + + if (!isSpecial(nCharLast)) + nEndIndex += 1; + + if (nStartIndex < nEndIndex) + { + sal_uInt32 nChars = nEndIndex - nStartIndex; + text(rStream, &aSeq[nStartIndex], nChars); + + if (isSpecial(nCharLast)) + { + resolveSpecialChar(nCharLast, rStream); + text(rStream, &aSeq[nEndIndex], 1); + } + } + } + else + { + sal_uInt32 nStartIndex = 0; + sal_uInt32 nEndIndex = nCount - 2; + + sal_uInt32 nCharFirst = aSeq[0] + (aSeq[1] << 8); + sal_uInt32 nCharLast = aSeq[nEndIndex] + (aSeq[nEndIndex + 1]); + + if (isSpecial(nCharFirst)) + { + nStartIndex += 2; + resolveSpecialChar(nCharFirst, rStream); + utext(rStream, &aSeq[0], 1); + } + + if (!isSpecial(nCharLast)) + nEndIndex += 2; + + if (nStartIndex < nEndIndex) + { + sal_uInt32 nChars = (nEndIndex - nStartIndex) / 2; + utext(rStream, &aSeq[nStartIndex], nChars); + + if (isSpecial(nCharLast)) + { + resolveSpecialChar(nCharLast, rStream); + utext(rStream, &aSeq[nEndIndex], 1); + } + } + } + } +} + +void WW8DocumentImpl::startCharacterGroup(Stream & rStream) +{ + if (mbInCharacterGroup) + endCharacterGroup(rStream); + +#ifdef DEBUG_ELEMENT + debug_logger->startElement("charactergroup"); +#endif + + rStream.startCharacterGroup(); + mbInCharacterGroup = true; +} + +void WW8DocumentImpl::endCharacterGroup(Stream & rStream) +{ +#ifdef DEBUG_ELEMENT + debug_logger->endElement("charactergroup"); +#endif + + rStream.endCharacterGroup(); + mbInCharacterGroup = false; +} + +void WW8DocumentImpl::startParagraphGroup(Stream & rStream) +{ + if (mbInParagraphGroup) + endParagraphGroup(rStream); + +#ifdef DEBUG_ELEMENT + debug_logger->startElement("paragraphgroup"); +#endif + + rStream.startParagraphGroup(); + mbInParagraphGroup = true; +} + +void WW8DocumentImpl::endParagraphGroup(Stream & rStream) +{ + if (mbInCharacterGroup) + endCharacterGroup(rStream); + +#ifdef DEBUG_ELEMENT + debug_logger->endElement("paragraphgroup"); +#endif + rStream.endParagraphGroup(); + mbInParagraphGroup = false; +} + +void WW8DocumentImpl::startSectionGroup(Stream & rStream) +{ + if (mbInSection) + endSectionGroup(rStream); + +#ifdef DEBUG_ELEMENT + debug_logger->startElement("sectiongroup"); +#endif + + rStream.startSectionGroup(); + mbInSection = true; +} + +void WW8DocumentImpl::endSectionGroup(Stream & rStream) +{ + if (mbInParagraphGroup) + endParagraphGroup(rStream); + +#ifdef DEBUG_ELEMENT + debug_logger->endElement("sectiongroup"); +#endif + rStream.endSectionGroup(); + mbInSection = false; +} + +void WW8DocumentImpl::resolve(Stream & rStream) +{ + if (! bSubDocument) + { + + //mpPieceTable->dump(clog); + + //copy(mCpAndFcs.begin(), mCpAndFcs.end(), ostream_iterator<CpAndFc>(clog, ", ")); + + //mpDocStream->dump(output); + + //output.addItem(mTextboxHeaderEndCpAndFc.toString()); + +#if 1 + output.addItem("<substream-names>"); + output.addItem(mpStream->getSubStreamNames()); + output.addItem("</substream-names>"); + + if (mpDocStream.get() != NULL) + { + mpDocStream->dump(output); + } + + if (mpSummaryInformationStream.get() != NULL) + { + mpSummaryInformationStream->dump(output); + } +#endif + + writerfilter::Reference<Properties>::Pointer_t pFib + (new WW8Fib(*mpFib)); + rStream.props(pFib); + + if (mpFibRgFcLcb2000.get() != NULL) + { + writerfilter::Reference<Properties>::Pointer_t pFibRgFcLcb2000 + (new WW8FibRgFcLcb2000(*mpFibRgFcLcb2000)); + rStream.props(pFibRgFcLcb2000); + } + +#if 0 + if (mpTextBoxStories.get() != NULL) + { + output.addItem("<textbox.boxes>"); + mpTextBoxStories->dump(output); + output.addItem("</textbox.boxes>"); + } +#endif + if (mpFib->get_lcbPlcftxbxBkd() > 0) + { + PLCF<WW8BKD> aPLCF(*mpTableStream, + mpFib->get_fcPlcftxbxBkd(), + mpFib->get_lcbPlcftxbxBkd()); +#if 0 + output.addItem("<textbox.breaks>"); + aPLCF.dump(output); + output.addItem("</textbox.breaks>"); +#endif + } + + if (mpDffBlock.get() != NULL) + { + DffBlock * pTmp = new DffBlock(*mpDffBlock); + //pTmp->dump(clog); + writerfilter::Reference<Properties>::Pointer_t pDffBlock = + writerfilter::Reference<Properties>::Pointer_t(pTmp); + + rStream.props(pDffBlock); + } + + { + rStream.info("headers"); + sal_uInt32 nHeaderCount = getHeaderCount(); + for (sal_uInt32 n = 0; n < nHeaderCount; ++n) + { + rStream.info(getHeaderCpAndFc(n).toString()); + } + rStream.info("/headers"); + } + +#if 0 + { + sal_uInt32 nFootnoteCount = getFootnoteCount(); + for (sal_uInt32 n = 0; n < nFootnoteCount; ++n) + { + //clog << "<footnote num=\"" << n << "\"/>" << endl; + + writerfilter::Reference<Stream>::Pointer_t pFootnote(getFootnote(n)); + + if (pFootnote.get() != NULL) + rStream.substream(NS_rtf::LN_footnote, pFootnote); + } + } + { + sal_uInt32 nEndnoteCount = getEndnoteCount(); + for (sal_uInt32 n = 0; n < nEndnoteCount; ++n) + { + //clog << "<endnote num=\"" << n << "\"/>" << endl; + + writerfilter::Reference<Stream>::Pointer_t pEndnote(getEndnote(n)); + + if (pEndnote.get() != NULL) + rStream.substream(NS_rtf::LN_endnote, pEndnote); + } + } +#endif + + writerfilter::Reference<Table>::Pointer_t pSttbRgtplc = getListTplcs(); + + if (pSttbRgtplc.get() != NULL) + rStream.table(NS_rtf::LN_SttbRgtplc, pSttbRgtplc); + + writerfilter::Reference<Table>::Pointer_t pFontTable = getFontTable(); + + if (pFontTable.get() != NULL) + rStream.table(NS_rtf::LN_FONTTABLE, pFontTable); + + try + { + writerfilter::Reference<Table>::Pointer_t pStyleSheet = getStyleSheet(); + + if (pStyleSheet.get() != NULL) + rStream.table(NS_rtf::LN_STYLESHEET, pStyleSheet); + } + catch (Exception e) + { + clog << e.getText() << endl; + } + + writerfilter::Reference<Table>::Pointer_t pAssocTable = getAssocTable(); + + if (pAssocTable.get() != NULL) + rStream.table(NS_rtf::LN_SttbAssoc, pAssocTable); + + writerfilter::Reference<Table>::Pointer_t pListTable = getListTable(); + + if (pListTable.get() != NULL) + rStream.table(NS_rtf::LN_LISTTABLE, pListTable); + + writerfilter::Reference<Table>::Pointer_t pLFOTable = getLFOTable(); + + if (pLFOTable.get() != NULL) + rStream.table(NS_rtf::LN_LFOTABLE, pLFOTable); + } + + WW8DocumentIterator::Pointer_t pIt = begin(); + WW8DocumentIterator::Pointer_t pItEnd = end(); + + mbInParagraphGroup = false; + mbInCharacterGroup = false; + mbInSection = false; + + sal_uInt32 nSectionIndex = 0; + + rStream.info(pIt->toString()); + rStream.info(pItEnd->toString()); + + while (! pIt->equal(*pItEnd)) + { + writerfilter::Reference<Properties>::Pointer_t + pProperties(pIt->getProperties()); + + switch (pIt->getPropertyType()) + { + case PROP_FOOTNOTE: + { + rStream.info(pIt->toString()); + writerfilter::Reference<Stream>::Pointer_t + pFootnote(pIt->getSubDocument()); + + if (pFootnote.get() != NULL) + { +#ifdef DEBUG_ELEMENT + debug_logger->startElement("substream"); +#endif + rStream.substream(NS_rtf::LN_footnote, pFootnote); +#ifdef DEBUG_ELEMENT + debug_logger->endElement("substream"); +#endif + } + } + break; + case PROP_ENDNOTE: + { + rStream.info(pIt->toString()); + writerfilter::Reference<Stream>::Pointer_t + pEndnote(pIt->getSubDocument()); + + if (pEndnote.get() != NULL) + { +#ifdef DEBUG_ELEMENT + debug_logger->startElement("substream"); +#endif + rStream.substream(NS_rtf::LN_endnote, pEndnote); +#ifdef DEBUG_ELEMENT + debug_logger->endElement("substream"); +#endif + } + } + break; + case PROP_ANNOTATION: + { + rStream.info(pIt->toString()); + writerfilter::Reference<Stream>::Pointer_t + pAnnotation(pIt->getSubDocument()); + + if (pAnnotation.get() != NULL) + { +#ifdef DEBUG_ELEMENT + debug_logger->startElement("substream"); +#endif + rStream.substream(NS_rtf::LN_annotation, pAnnotation); +#ifdef DEBUG_ELEMENT + debug_logger->endElement("substream"); +#endif + } + } + break; + case PROP_CHP: + { + startCharacterGroup(rStream); + } + + break; + case PROP_PAP: + { + startParagraphGroup(rStream); + rStream.info(pIt->toString()); + } + + break; + case PROP_SEC: + { + startSectionGroup(rStream); + rStream.info(pIt->toString()); + + if (nSectionIndex == 0) + rStream.props(getDocumentProperties()); + + sal_uInt32 nHeaderStartIndex = 6 + nSectionIndex * 6; + sal_uInt32 nHeaderEndIndex = nHeaderStartIndex + 6; + + if (nHeaderStartIndex >= getHeaderCount()) + nHeaderStartIndex = getHeaderCount(); + + if (nHeaderEndIndex >= getHeaderCount()) + nHeaderEndIndex = getHeaderCount(); + + for (sal_uInt32 n = nHeaderStartIndex; n < nHeaderEndIndex; ++n) + { + writerfilter::Reference<Stream>::Pointer_t + pHeader(getHeader(n)); + + Id qName = lcl_headerQName(n); + + if (pHeader.get() != NULL) + rStream.substream(qName, pHeader); + } + + ++nSectionIndex; + } + + break; + default: + rStream.info(pIt->toString()); + } + + if (pProperties.get() != NULL) + { +#ifdef DEBUG_PROPERTIES + PropertySetToTagHandler aHandler(IdToString::Pointer_t(new WW8IdToString())); + pProperties->resolve(aHandler); + debug_logger->addTag(aHandler.getTag()); +#endif + + rStream.props(pProperties); + } + + if (pIt->getPropertyType() == PROP_PAP) + { + startCharacterGroup(rStream); + } + + resolveText(pIt, rStream); + + ++(*pIt); + } + + if (mbInCharacterGroup) + endCharacterGroup(rStream); + + if (mbInParagraphGroup) + endParagraphGroup(rStream); + + if (mbInSection) + endSectionGroup(rStream); + +} + +WW8Stream::Pointer_t +WW8DocumentFactory::createStream(uno::Reference<uno::XComponentContext> rContext, + uno::Reference<io::XInputStream> rStream) +{ + return WW8Stream::Pointer_t(new WW8StreamImpl(rContext, rStream)); +} + +WW8Document * +WW8DocumentFactory::createDocument(WW8Stream::Pointer_t rpStream) +{ + return new WW8DocumentImpl(rpStream); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8SED::get_sepx() +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + if (get_fcSepx() != 0xffffffff) + { + WW8StructBase aTmp(*mpDoc->getDocStream(), get_fcSepx(), 2); + pResult = writerfilter::Reference<Properties>::Pointer_t + (new WW8PropertySetImpl + (*mpDoc->getDocStream(), get_fcSepx() + 2, + (sal_uInt32) aTmp.getU16(0), false)); + } + + return pResult; +} + +void WW8DocumentImpl::insertCpAndFc(const CpAndFc & rCpAndFc) +{ + mCpAndFcs.insert(rCpAndFc); +} + +string propertyTypeToString(PropertyType nType) +{ + string result; + + switch (nType) + { + case PROP_SHP: + result = "SHP"; + + break; + case PROP_FLD: + result = "FLD"; + + break; + case PROP_BOOKMARKSTART: + result = "BOOKMARKSTART"; + + break; + case PROP_BOOKMARKEND: + result = "BOOKMARKEND"; + + break; + case PROP_ENDNOTE: + result = "ENDNOTE"; + + break; + case PROP_FOOTNOTE: + result = "FOOTNOTE"; + + break; + case PROP_ANNOTATION: + result = "ANNOTATION"; + + break; + case PROP_DOC: + result = "DOC"; + + break; + + case PROP_SEC: + result = "SEC"; + + break; + + case PROP_PAP: + result = "PAP"; + + break; + + case PROP_CHP: + result = "CHP"; + + break; + default: + break; + } + + return result; +} + +string CpAndFc::toString() const +{ + string result; + + result += "("; + result += getCp().toString(); + result += ", "; + result += getFc().toString(); + result += ", "; + + result += propertyTypeToString(getType()); + + result += ")"; + + return result; +} + + +// Bookmark + +Bookmark::Bookmark(writerfilter::Reference<Properties>::Pointer_t pBKF, + rtl::OUString & rName) +: mpBKF(pBKF), mName(rName) +{ +} + +void Bookmark::resolve(Properties & rHandler) +{ + mpBKF->resolve(rHandler); + + WW8Value::Pointer_t pValue = createValue(mName); + rHandler.attribute(NS_rtf::LN_BOOKMARKNAME, *pValue); +} + +string Bookmark::getType() const +{ + return "Bookmark"; +} + +// BookmarkHelper + +CpAndFc BookmarkHelper::getStartCpAndFc(sal_uInt32 nPos) +{ + Cp aCp(mpStartCps->getFc(nPos)); + Fc aFc(mpPieceTable->cp2fc(aCp)); + CpAndFc aCpAndFc(aCp, aFc, PROP_BOOKMARKSTART); + + return aCpAndFc; +} + +CpAndFc BookmarkHelper::getEndCpAndFc(sal_uInt32 nPos) +{ + Cp aCp(mpEndCps->getU32(nPos * 4)); + Fc aFc(mpPieceTable->cp2fc(aCp)); + CpAndFc aCpAndFc(aCp, aFc, PROP_BOOKMARKEND); + + return aCpAndFc; +} + +rtl::OUString BookmarkHelper::getName(sal_uInt32 nPos) +{ + return mpNames->getEntry(nPos); +} + +sal_uInt32 BookmarkHelper::getIndex(const CpAndFc & rCpAndFc) +{ + sal_uInt32 nResult = mpStartCps->getEntryCount(); + + sal_uInt32 nCp = rCpAndFc.getCp().get(); + + sal_uInt32 n; + switch (rCpAndFc.getType()) + { + case PROP_BOOKMARKSTART: + { + sal_uInt32 nStartsCount = mpStartCps->getEntryCount(); + + for (n = 0; n < nStartsCount; ++n) + { + if (nCp == mpStartCps->getFc(n)) + { + nResult = n; + + break; + } + } + + if (n == nStartsCount) + throw ExceptionNotFound("BookmarkHelper::getIndex"); + } + + break; + + case PROP_BOOKMARKEND: + { + sal_uInt32 nEndsCount = mpEndCps->getCount() / 4; + sal_uInt32 nIndex = nEndsCount; + + for (n = 0; n < nEndsCount; ++n) + { + if (nCp == mpEndCps->getU16(n * 4)) + { + nIndex = n; + + break; + } + } + + if (n == nEndsCount) + throw ExceptionNotFound("BookmarkHelper::getIndex"); + + { + { + sal_uInt32 nStartsCount = mpStartCps->getEntryCount(); + for (n = 0; n < nStartsCount; ++n) + { + WW8BKF::Pointer_t pBKF(mpStartCps->getEntry(n)); + + if (pBKF->get_ibkl() == + sal::static_int_cast<sal_Int32>(nIndex)) + { + nResult = n; + + break; + } + } + + if (n == nStartsCount) + throw ExceptionNotFound("BookmarkHelper::getIndex"); + } + } + } + + break; + default: + break; + } + + return nResult; +} + +void BookmarkHelper::init() +{ + { + sal_uInt32 nStartsCount = mpStartCps->getEntryCount(); + + for (sal_uInt32 n = 0; n < nStartsCount; ++n) + mpDoc->insertCpAndFc(getStartCpAndFc(n)); + } + + { + sal_uInt32 nEndsCount = mpEndCps->getCount() / 4; + + for (sal_uInt32 n = 0; n < nEndsCount; ++n) + mpDoc->insertCpAndFc(getEndCpAndFc(n)); + } +} + +writerfilter::Reference<Properties>::Pointer_t +BookmarkHelper::getBKF(const CpAndFc & rCpAndFc) +{ + sal_uInt32 nIndex = getIndex(rCpAndFc); + + return writerfilter::Reference<Properties>::Pointer_t + (mpStartCps->getEntryPointer(nIndex)); +} + +writerfilter::Reference<Properties>::Pointer_t +BookmarkHelper::getBookmark(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + try + { + rtl::OUString aName = getName(rCpAndFc); + + pResult = writerfilter::Reference<Properties>::Pointer_t + (new Bookmark(getBKF(rCpAndFc), aName)); + } + catch (ExceptionNotFound e) + { + clog << e.getText() << endl; + } + + return pResult; +} + +rtl::OUString BookmarkHelper::getName(const CpAndFc & rCpAndFc) +{ + rtl::OUString sResult; + + sal_uInt32 nIndex = getIndex(rCpAndFc); + + sResult = getName(nIndex); + + return sResult; +} + +template <class T, class Helper> +struct ProcessPLCF2Map +{ + void process(typename PLCF<T>::Pointer_t pPlcf, + typename Helper::Map_t & rMap, + PropertyType type, + WW8DocumentImpl * pDoc) + { + if (pPlcf.get() != NULL) + { + sal_uInt32 nCount = pPlcf->getEntryCount(); + + for (sal_uInt32 n = 0; n < nCount; n++) + { + Cp aCp(pPlcf->getFc(n)); + CpAndFc aCpAndFc(pDoc->getCpAndFc(aCp, type)); + typename T::Pointer_t pT = pPlcf->getEntry(n); + + rMap[aCpAndFc] = pT; + } + } + } +}; + +FieldHelper::FieldHelper(PLCF<WW8FLD>::Pointer_t pPlcffldMom, + WW8DocumentImpl * pDoc) +: mpDoc(pDoc) +{ + ProcessPLCF2Map<WW8FLD, FieldHelper> process; + process.process(pPlcffldMom, mMap, PROP_FLD, pDoc); +} + +void FieldHelper::init() +{ + Map_t::iterator aIt; + + for (aIt = mMap.begin(); aIt != mMap.end(); aIt++) + { + mpDoc->insertCpAndFc(aIt->first); + } +} + +WW8FLD::Pointer_t FieldHelper::getWW8FLD(const CpAndFc & rCpAndFc) +{ + WW8FLD::Pointer_t pFld = mMap[rCpAndFc]; + + return pFld; +} + +writerfilter::Reference<Properties>::Pointer_t +FieldHelper::getField(const CpAndFc & rCpAndFc) +{ + WW8FLD::Pointer_t pFLD = getWW8FLD(rCpAndFc); + + return writerfilter::Reference<Properties>::Pointer_t + (new WW8FLD(*pFLD)); +} + +ShapeHelper::ShapeHelper(PLCF<WW8FSPA>::Pointer_t pPlcspaMom, + PLCF<WW8FSPA>::Pointer_t pPlcspaHdr, + WW8DocumentImpl * pDoc) +: mpDoc(pDoc) +{ + ProcessPLCF2Map<WW8FSPA, ShapeHelper> process; + process.process(pPlcspaMom, mMap, PROP_SHP, pDoc); + process.process(pPlcspaHdr, mMap, PROP_SHP, pDoc); +} + +void ShapeHelper::init() +{ + Map_t::iterator aIt; + + for (aIt = mMap.begin(); aIt != mMap.end(); aIt++) + { + mpDoc->insertCpAndFc(aIt->first); + aIt->second->setDocument(mpDoc); + } +} + +writerfilter::Reference<Properties>::Pointer_t +ShapeHelper::getShape(const CpAndFc & rCpAndFc) +{ + WW8FSPA::Pointer_t pFSPA = mMap[rCpAndFc]; + + return writerfilter::Reference<Properties>::Pointer_t + (new WW8FSPA(*pFSPA)); +} + +BreakHelper::BreakHelper(PLCF<WW8BKD>::Pointer_t pPlcfbkdMom, + WW8DocumentImpl * pDoc) +: mpDoc(pDoc) +{ + ProcessPLCF2Map<WW8BKD, BreakHelper> process; + process.process(pPlcfbkdMom, mMap, PROP_BRK, pDoc); +} + +void BreakHelper::init() +{ + Map_t::iterator aIt; + + for (aIt = mMap.begin(); aIt != mMap.end(); aIt++) + { + mpDoc->insertCpAndFc(aIt->first); + } +} + +writerfilter::Reference<Properties>::Pointer_t +BreakHelper::getBreak(const CpAndFc & rCpAndFc) +{ + WW8BKD::Pointer_t pBKD = mMap[rCpAndFc]; + + return writerfilter::Reference<Properties>::Pointer_t + (new WW8BKD(*pBKD)); +} + + +}} diff --git a/writerfilter/source/doctok/WW8DocumentImpl.hxx b/writerfilter/source/doctok/WW8DocumentImpl.hxx new file mode 100644 index 000000000000..a1f7e8abb2b4 --- /dev/null +++ b/writerfilter/source/doctok/WW8DocumentImpl.hxx @@ -0,0 +1,848 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_DOCUMENT_IMPL_HXX +#define INCLUDED_WW8_DOCUMENT_IMPL_HXX + +#include <set> +#include <WW8PieceTable.hxx> +#include <WW8BinTable.hxx> +#include <resources.hxx> +#ifndef INCLUDED_WW8_RESOURCE_MODEL_HXX +#include <resourcemodel/WW8ResourceModel.hxx> +#endif +#include <PLCF.hxx> +#include <WW8Sttbf.hxx> +#include <XNoteHelper.hxx> + +namespace writerfilter { +namespace doctok +{ + +class WW8DocumentImpl; + +/** + A bookmark. +*/ +class Bookmark : public writerfilter::Reference<Properties> +{ + /// bookmark first descriptor + writerfilter::Reference<Properties>::Pointer_t mpBKF; + + /// name of bookmark + rtl::OUString mName; + +public: + Bookmark(writerfilter::Reference<Properties>::Pointer_t pBKF, + rtl::OUString & rName); + + /** + Resolve bookmark to handler. + + @param rHandler handler to send events to + */ + virtual void resolve(Properties & rHandler); + + virtual string getType() const; +}; + +/** + A helper for bookmarks. + */ +class BookmarkHelper +{ + /// PLCF containing Cps and BKFs for the bookmarks + PLCF<WW8BKF>::Pointer_t mpStartCps; + + /// Cps of the ends of bookmarks + WW8StructBase::Pointer_t mpEndCps; + + /// STTBF containing the names of bookmarks + WW8Sttbf::Pointer_t mpNames; + + /// piece table for converting CPs to FCs + WW8PieceTable::Pointer_t mpPieceTable; + + /// document to insert CpAndFcs to + WW8DocumentImpl * mpDoc; + + /** + Return start CpAndFc for a bookmark. + + @param nPos index of the bookmark + */ + CpAndFc getStartCpAndFc(sal_uInt32 nPos); + + /** + Return end CpAndFc for a bookmark. + + @param nPos index of the bookmark + */ + CpAndFc getEndCpAndFc(sal_uInt32 nPos); + + /** + Return the name of a bookmark. + + @param nPos index of the bookmark + */ + rtl::OUString getName(sal_uInt32 nPos); + + /** + Return index of a bookmark. + + @param rCpAndFc CpAndFc of the bookmark + */ + sal_uInt32 getIndex(const CpAndFc & rCpAndFc); + +public: + typedef boost::shared_ptr<BookmarkHelper> Pointer_t; + + BookmarkHelper(PLCF<WW8BKF>::Pointer_t pStartCps, + WW8StructBase::Pointer_t pEndCps, + WW8Sttbf::Pointer_t pNames, + WW8PieceTable::Pointer_t pPieceTable, + WW8DocumentImpl * pDoc) + : mpStartCps(pStartCps), mpEndCps(pEndCps), mpNames(pNames), + mpPieceTable(pPieceTable), mpDoc(pDoc) + { + } + + /** + Initialize. + + Inserts CpAndFcs for the bookmark starts and ends into the + document. + */ + void init(); + + /** + Return BKF of a bookmark. + + @param rCpAndFc CpAndFc of the bookmark + */ + writerfilter::Reference<Properties>::Pointer_t getBKF + (const CpAndFc & rCpAndFc); + + /** + Return the name of a bookmark. + + @param rCpAndFc CpAndFc of the bookmark + */ + rtl::OUString getName(const CpAndFc & rCp); + + /** + Return bookmark. + @param rCpAndFc CpAndFc of the bookmark + */ + writerfilter::Reference<Properties>::Pointer_t + getBookmark(const CpAndFc & rCpAndFc); +}; + +/** + Helper for shapes. + */ +class ShapeHelper +{ +public: + typedef hash_map<CpAndFc, WW8FSPA::Pointer_t, CpAndFcHash> Map_t; + +private: + WW8DocumentImpl * mpDoc; + Map_t mMap; + +public: + typedef boost::shared_ptr<ShapeHelper> Pointer_t; + ShapeHelper(PLCF<WW8FSPA>::Pointer_t pPlcspaMom, + PLCF<WW8FSPA>::Pointer_t pPlcspaHdr, + WW8DocumentImpl * pDoc); + + void init(); + + writerfilter::Reference<Properties>::Pointer_t + getShape(const CpAndFc & rCpAndFc); + +}; + +/** + Helper for fields. + */ +class FieldHelper +{ +public: + typedef hash_map<CpAndFc, WW8FLD::Pointer_t, + CpAndFcHash> Map_t; + +private: + WW8DocumentImpl * mpDoc; + Map_t mMap; +public: + + typedef boost::shared_ptr<FieldHelper> Pointer_t; + FieldHelper(PLCF<WW8FLD>::Pointer_t pPlcffldMom, + WW8DocumentImpl * pDoc); + + void init(); + + writerfilter::Reference<Properties>::Pointer_t + getField(const CpAndFc & rCpAndFc); + + WW8FLD::Pointer_t getWW8FLD(const CpAndFc & rCpAndFc); +}; + +/** + Helper for Breaks. +*/ +class BreakHelper +{ +public: + typedef hash_map<CpAndFc, WW8BKD::Pointer_t, + CpAndFcHash> Map_t; +private: + WW8DocumentImpl * mpDoc; + Map_t mMap; +public: + typedef boost::shared_ptr<BreakHelper> Pointer_t; + BreakHelper(PLCF<WW8BKD>::Pointer_t pPlcfbkdMom, + WW8DocumentImpl * pDoc); + + void init(); + + writerfilter::Reference<Properties>::Pointer_t + getBreak(const CpAndFc & rCpAndFc); +}; + +/** + Implementation class for document. + */ +class WW8DocumentImpl : public WW8Document +{ + /// true if the document is contained in another document + bool bSubDocument; + + /// picture location + sal_uInt32 mfcPicLoc; + + /// true if FFDATA structure is found at offset mfcPicLoc in data stream + bool mbPicIsData; + + /// current field descriptor + WW8FLD::Pointer_t mpFLD; + + /// CpAndFcs in the document where properties change + CpAndFcs mCpAndFcs; + + /// CpAndFc pointing to the start of the document + CpAndFc mCpAndFcStart; + + /// CpAndFc pointing to the end of the document + CpAndFc mCpAndFcEnd; + + /// pointer to the cache of FKPs containing character properties + WW8FKPCache::Pointer_t mpCHPFKPCache; + + /// pointer to the cache of FPKs containing paragraph properties + WW8FKPCache::Pointer_t mpPAPFKPCache; + + /// pointer to the stream containing the whole document + WW8Stream::Pointer_t mpStream; + + /// pointer to the substream of the document containing table like + /// structures + WW8Stream::Pointer_t mpTableStream; + + /// pointer to the substream of the document containing the + /// document contents and formatting information + WW8Stream::Pointer_t mpDocStream; + + /// pointer to the data stream of the document + WW8Stream::Pointer_t mpDataStream; + + /// pointer to the compound object stream of the document + WW8Stream::Pointer_t mpCompObjStream; + + /// pointer to the summayry information stream of the document + WW8Stream::Pointer_t mpSummaryInformationStream; + + /// pointer to the piece table + WW8PieceTable::Pointer_t mpPieceTable; + + /// pointer to the bin table for paragraph properties + WW8BinTable::Pointer_t mpBinTablePAPX; + + /// pointer to the bin table for character properties + WW8BinTable::Pointer_t mpBinTableCHPX; + + /// PLCF containing the section descriptions + PLCF<WW8SED>::Pointer_t mpSEDs; + + /// pointer to the file information block + WW8Fib::Pointer_t mpFib; + + /// pointer to the file information block for post 2000 documents + WW8FibRgFcLcb2000::Pointer_t mpFibRgFcLcb2000; + + /// pointer to the offsets of headers/footers + WW8StructBase::Pointer_t mpHeaderOffsets; + + /// pointer to the helper for footnotes + XNoteHelper<WW8FRD>::Pointer_t mpFootnoteHelper; + + /// pointer to the helper for endnotes + XNoteHelper<WW8FRD>::Pointer_t mpEndnoteHelper; + + /// pointer to the helper for annotations + XNoteHelper<WW8ATRD>::Pointer_t mpAnnotationHelper; + + /// pointer to the helper for bookmarks + BookmarkHelper::Pointer_t mpBookmarkHelper; + + /// pointer to the helper for fields + FieldHelper::Pointer_t mpFieldHelper; + + /// pointer to the helper for shapes + ShapeHelper::Pointer_t mpShapeHelper; + + /// pointer to the helper for breaks + BreakHelper::Pointer_t mpBreakHelper; + + + /// cache for the Cp where main text flow end + CpAndFc mDocumentEndCpAndFc; + + /// cache for the Cp where footnotes section ends + CpAndFc mFootnoteEndCpAndFc; + + /// cache for the Cp where header section ends + CpAndFc mHeaderEndCpAndFc; + + /// cache for the Cp where annotation section ends + CpAndFc mAnnotationEndCpAndFc; + + /// cache for the Cp where endnote section ends + CpAndFc mEndnoteEndCpAndFc; + + /// cache for the Cp where textbox section ends + CpAndFc mTextboxEndCpAndFc; + + /// cache for the Cp where textbox in header section ends + CpAndFc mTextboxHeaderEndCpAndFc; + + /// DffBlock of document + DffBlock::Pointer_t mpDffBlock; + + /// Textbox stories + PLCF<WW8FTXBXS>::Pointer_t mpTextBoxStories; + + bool mbInSection; + bool mbInParagraphGroup; + bool mbInCharacterGroup; + + bool isSpecial(sal_uInt32 nChar); + + WW8Stream::Pointer_t getSubStream(const ::rtl::OUString & sId) const; + + /** + Parse bin table and create CpAndFcs for all points in the + document where properties of the given type change. + + @param rTable bin table to parse + @param eType_ type of CpAndFcs to create + */ + void parseBinTableCpAndFcs(WW8BinTable & rTable, PropertyType eType_); + + void startCharacterGroup(Stream & rStream); + void endCharacterGroup(Stream & rStream); + void startParagraphGroup(Stream & rStream); + void endParagraphGroup(Stream & rStream); + void startSectionGroup(Stream & rStream); + void endSectionGroup(Stream & rStream); + void text(Stream & rStream, const sal_uInt8 * data, size_t len); + void utext(Stream & rStream, const sal_uInt8 * data, size_t len); + +public: + WW8DocumentImpl(WW8Stream::Pointer_t rpStream); + WW8DocumentImpl(const WW8DocumentImpl & rSrc, + const CpAndFc & rStart, const CpAndFc & rEnd); + virtual ~WW8DocumentImpl(); + + virtual WW8DocumentImpl & Assign(const WW8DocumentImpl & rSrc); + + virtual string getType() const; + + virtual WW8Document::Pointer_t getSubDocument(SubDocumentId nId); + virtual WW8DocumentIterator::Pointer_t getIterator + (const CpAndFc & rCpAndFc); + virtual WW8DocumentIterator::Pointer_t begin(); + virtual WW8DocumentIterator::Pointer_t end(); + + virtual WW8Stream::Sequence getText(const CpAndFc & rStart); + + /** + Returns the document stream. + */ + + WW8Stream::Pointer_t getDocStream() const; + + /** + Returns the data stream. + */ + WW8Stream::Pointer_t getDataStream() const; + + /** + Returns distance in bytes to next CpAndFc. + + @param rCpAndFc CpAndFc to start at + */ + sal_uInt32 getByteLength(const CpAndFc & rCpAndFc) const; + + /** + Returns first character position in document. + */ + const CpAndFc & getFirstCp() const; + + /** + Returns last character position in document. + */ + const CpAndFc & getLastCp() const; + + /** + Returns next character position with change in properties. + + @param rCpAndFc position to start at + */ + CpAndFc getNextCp(const CpAndFc & rCpAndFc) const; + + /** + Returns previous character position with change in properties. + + @param rCpAndFc position to start at + */ + CpAndFc getPrevCp(const CpAndFc & rCpAndFc) const; + + /** + Returns character position where main text flow ends. + */ + CpAndFc getDocumentEndCp() const; + + /** + Returns character position where footnotes end. + */ + CpAndFc getFootnodeEndCp() const; + + /** + Returns character position where headers end. + */ + CpAndFc getHeaderEndCp() const; + + /** + Returns character position where annatations end. + */ + CpAndFc getAnnotationEndCp() const; + + /** + Returns character position where endnotes end. + */ + CpAndFc getEndnoteEndCp() const; + + /** + Returns character position where textboxes end. + */ + CpAndFc getTextboxEndCp() const; + + /** + Returns character positoion where textboxes in headers end. + */ + CpAndFc getTextboxHeaderEndCp() const; + + /** + Insert CpAndFc to set of CpAndFcs. + + @param rCpAndFc CpAndFc to insert + */ + void insertCpAndFc(const CpAndFc & rCpAndFc); + + /** + Return FKP for certain CpAndFc. + + @param rCpAndFc CpAndFc for which the FKP is looked for + */ + WW8FKP::Pointer_t getFKP(const CpAndFc & rCpAndFc); + + /** + Return FKP containing character properties. + + @param nIndex index of FKP to return + @param bComplex true if FKP contains complex FCs + */ + WW8FKP::Pointer_t getFKPCHPX(sal_uInt32 nIndex, bool bComplex); + + /** + Return FKP containing paragraph properties. + + @param nIndex index of FKP to return + @param bComplex true if FKP contains complex FCs + */ + WW8FKP::Pointer_t getFKPPAPX(sal_uInt32 nIndex, bool bComplex); + + /** + Return property set valid at a certain CpAndFc. + + @param rCpAndFc CpAndFc to look at + */ + writerfilter::Reference<Properties>::Pointer_t + getProperties(const CpAndFc & rCpAndFc); + + /** + Return subdocument referenced at a certain point in document. + + @param rCpAndFc CpAndFc where subdocument is referenced + */ + writerfilter::Reference<Stream>::Pointer_t + getSubDocument(const CpAndFc & rCpAndFc); + + /** + Return section description at a certain CpAndFc. + + @param rCpAndFc CpAndFc to look at + */ + WW8SED * getSED(const CpAndFc & rCpAndFc) const; + + /** + Return reference to list plcs. + */ + writerfilter::Reference<Table>::Pointer_t getListTplcs() const; + + /** + Return reference to list table. + */ + writerfilter::Reference<Table>::Pointer_t getListTable() const; + + /** + Return reference to table of list level overrides. + */ + writerfilter::Reference<Table>::Pointer_t getLFOTable() const; + + /** + Return reference to font table. + */ + writerfilter::Reference<Table>::Pointer_t getFontTable() const; + + /** + Return reference to style sheet. + */ + writerfilter::Reference<Table>::Pointer_t getStyleSheet() const; + + /** + Return reference to associated data. + */ + writerfilter::Reference<Table>::Pointer_t getAssocTable() const; + + /** + Return count of headers/footers. + */ + sal_uInt32 getHeaderCount() const; + + /** + Return CpAndFc for a header or footer. + + @param nPos index in the list of headers and footers + */ + CpAndFc getHeaderCpAndFc(sal_uInt32 nPos); + + /** + Return subdocument for header/footer. + + @param nPos index in the list of headers and footers + */ + writerfilter::Reference<Stream>::Pointer_t getHeader(sal_uInt32 nPos); + + /** + Return count of footnotes. + */ + sal_uInt32 getFootnoteCount() const; + + /** + Return subdocument for footnote. + + @param nPos index of the footnote + */ + writerfilter::Reference<Stream>::Pointer_t getFootnote(sal_uInt32 nPos); + + /** + Return subdocument for footnote at a certain position in document. + + @param rCpAndFc position in document + */ + writerfilter::Reference<Stream>::Pointer_t getFootnote + (const CpAndFc & rCpAndFc); + + /** + Return count of endnotes. + */ + sal_uInt32 getEndnoteCount() const; + + /** + Return subdocument for an endnote. + + @param nPos index of the endnote + */ + writerfilter::Reference<Stream>::Pointer_t getEndnote(sal_uInt32 nPos); + + /** + Return subdocument for an endnote. + + @param rCpAndFc CpAndFc where endnote is referenced + */ + writerfilter::Reference<Stream>::Pointer_t getEndnote + (const CpAndFc & rCpAndFc); + + /** + Return count of annotations. + */ + sal_uInt32 getAnnotationCount() const; + + /** + Return subdocument for an annotation. + + @param nPos index of the annotation + */ + writerfilter::Reference<Stream>::Pointer_t getAnnotation(sal_uInt32 nPos); + + /** + Return subdocument for an annotation. + + @param rCpAndFc CpAndFc where annotation is referenced + */ + writerfilter::Reference<Stream>::Pointer_t getAnnotation + (const CpAndFc & rCpAndFc); + + /** + Return bookmark. + + @param rCpAndFc CpAndFc where bookmark begins or ends + */ + writerfilter::Reference<Properties>::Pointer_t + getBookmark(const CpAndFc & rCpAndFc) const; + + /** + Return shape. + + @param rCpAndFc CpAndFc of the shape + */ + writerfilter::Reference<Properties>::Pointer_t + getShape(const CpAndFc & rCpAndFc) const; + + writerfilter::Reference<Properties>::Pointer_t + getShape(sal_uInt32 nSpid); + + /** + Return blip. + + @param nBlib number of the blip to return + */ + writerfilter::Reference<Properties>::Pointer_t + getBlip(sal_uInt32 nBlib); + + /** + Return break descriptor. + + @param rCpAndFc CpAndFc of the break + */ + writerfilter::Reference<Properties>::Pointer_t + getBreak(const CpAndFc & rCpAndFc) const; + + + /** + Return field. + + @param rCpAndFc CpAndFc of the field + */ + writerfilter::Reference<Properties>::Pointer_t + getField(const CpAndFc & rCpAndFc) const; + + /** + Return document properties. + + */ + writerfilter::Reference<Properties>::Pointer_t + getDocumentProperties() const; + + /** + Return current field descriptor. + */ + WW8FLD::Pointer_t getCurrentFLD() const; + + /** + Return stream of text box. + + @param nShpId shape id of text box + */ + writerfilter::Reference<Stream>::Pointer_t + getTextboxText(sal_uInt32 nShpId) const; + + /** + Return file character position according to a character + position. + + @param cp the character position + */ + Fc cp2fc(const Cp & cp) const; + + /** + Return the character position according to file character + position. + + @param fc the file character position + */ + Cp fc2cp(const Fc & fc) const; + + /** + Return CpAndFc related to character position. + + @param cp the character position + */ + CpAndFc getCpAndFc(const Cp & cp, PropertyType type = PROP_DOC) const; + + /** + Return CpAndFc related to file character position. + + @param fc the file character position + */ + CpAndFc getCpAndFc(const Fc & fc, PropertyType type = PROP_DOC) const; + + sal_uInt32 getPicLocation() const; + void setPicLocation(sal_uInt32 fcPicLoc); + + bool isPicData(); + void setPicIsData(bool bPicIsData); + + /** + Create events for the document. + + @param rHandler handler to send the events to + */ + void resolve(Stream & rHandler); + + /** + Resolve text. + + The text of the given iterator is split at special + characters. Each run of non-special characters is send as one + event. Each run of special characters is send as one event. + + @param pIt iterator whose text is to be resolved + @param rStream handler for the events + */ + void resolveText(WW8DocumentIterator::Pointer_t pIt, Stream & rStream); + + /** + Resolve the picture at mfcPicLoc. + + @param rStream + */ + void resolvePicture(Stream & rStream); + + /** + Resolve special char. + + @param nChar the special char + @param rStream the stream handler to resolve the special char to + */ + void resolveSpecialChar(sal_uInt32 nChar, Stream & rStream); +}; + +/** + Implentation class for an iterator in a document. + */ +class WW8DocumentIteratorImpl : public WW8DocumentIterator +{ + /// pointer to the document + WW8DocumentImpl * mpDocument; + + /// CpAndFc the iterator is pointing to + CpAndFc mCpAndFc; + +public: + WW8DocumentIteratorImpl(WW8DocumentImpl * pDocument, + const CpAndFc & rCpAndFc) + : mpDocument(pDocument), mCpAndFc(rCpAndFc) + { + } + + virtual ~WW8DocumentIteratorImpl(); + + /** + Increase the iterator to the next character position. + */ + WW8DocumentIterator & operator++(); + + /** + Decrease the iterator to the previous character position. + */ + WW8DocumentIterator & operator--(); + + virtual writerfilter::Reference<Properties>::Pointer_t getProperties() + const; + //void setAttributes(const IAttributeSet & aAttributeSet); + + virtual writerfilter::Reference<Stream>::Pointer_t getSubDocument() const; + + /** Return if the text the iterator points to is complex. + + @attention The definition of a complex run of text in Word is + counter-intuitive: Complex runs use 8-bit encoding for characters, + non-complex ones use 16 bits. + */ + bool isComplex() const; + virtual PropertyType getPropertyType() const; + + virtual WW8Stream::Sequence getText(); + virtual bool equal(const WW8DocumentIterator & rIt) const; + + virtual string toString() const; + virtual void dump(ostream & o) const; + + /** + Return pointer to the shape at character position the iterator + is pointing to. + */ + virtual writerfilter::Reference<Properties>::Pointer_t getShape() const; + + /** + Return pointer to section description at character position the + iterator points to. + */ + WW8SED * getSED() const; +}; + +/** + Return string for property type. + */ +string propertyTypeToString(PropertyType nType); + +}} +#endif // INCLUDED_WW8_DOCUMENT_IMPL_HXX diff --git a/writerfilter/source/doctok/WW8FKP.hxx b/writerfilter/source/doctok/WW8FKP.hxx new file mode 100644 index 000000000000..af0af1b8e303 --- /dev/null +++ b/writerfilter/source/doctok/WW8FKP.hxx @@ -0,0 +1,133 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_FKP_HXX +#define INCLUDED_WW8_FKP_HXX + +#ifndef INCLUDES_WW8_CP_AND_FC_HXX +#include <WW8CpAndFc.hxx> +#endif +#ifndef INCLUDE_WW8_STRUCT_BASE_HXX +#include <WW8StructBase.hxx> +#endif + +namespace writerfilter { +namespace doctok +{ + +/** + A formated diskpage (FKP). + + Formatted diskpages are used by Word to store runs of SPRMs (single + property modifier). A FKP contains a list of file character + positions (FC). For each FC there is an entry containing the run of + SPRMs stored for that FC. + */ +class WW8FKP : public WW8StructBase +{ +public: + /** + Shared pointer to an FKP. + */ + typedef boost::shared_ptr<WW8FKP> Pointer_t; + + /** + Create FKP from stream. + + @param rStream stream to create FKP from + @param nOffset offset in stream where the FKP starts. + */ + WW8FKP(WW8Stream & rStream, sal_uInt32 nOffset) + : WW8StructBase(rStream, nOffset, 512) + { + } + + /** + Return count of entries. + */ + virtual sal_uInt32 getEntryCount() const = 0; + + /** + Return an FC. + + @param nIndex index of the FC to return + */ + virtual Fc getFc(sal_uInt32 nIndex) const = 0; + + /** + Returns the first FC of the FKP. + */ + virtual Fc getFirstFc() const = 0; + + /** + Returns the last FC of the FKP. + */ + virtual Fc getLastFc() const = 0; + + /** + Check if an FKP contains an FC. + + @param rFc FC to look for + + @retval true FKP contains FC + @retval false else + */ + virtual bool contains(const Fc & rFc) const = 0; + + /** + Return properties stored in an FKP for a FC. + + @param rFc FC to look for + */ + virtual writerfilter::Reference<Properties>::Pointer_t + getProperties(const Fc & rFc) + const = 0; +}; + +/** + Cache providing FKPs. + */ +class WW8FKPCache +{ +public: + /** + Shared pointer to cache. + */ + typedef boost::shared_ptr<WW8FKPCache> Pointer_t; + + virtual ~WW8FKPCache(); + + /** + Return FKP. + + @param nPageNumber number of page to return + */ + virtual WW8FKP::Pointer_t get(sal_uInt32 nPageNumber, bool bComplex) = 0; +}; +}} + +#endif // INCLUDED_WW8_FKP_HXX diff --git a/writerfilter/source/doctok/WW8FKPImpl.cxx b/writerfilter/source/doctok/WW8FKPImpl.cxx new file mode 100644 index 000000000000..354159bced0c --- /dev/null +++ b/writerfilter/source/doctok/WW8FKPImpl.cxx @@ -0,0 +1,240 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include "WW8FKPImpl.hxx" +#include "WW8PropertySetImpl.hxx" + +namespace writerfilter { +namespace doctok +{ +#if 0 +sal_uInt32 WW8FKPImpl::getIndex(const Fc & rFc) const +{ + sal_uInt32 nLeft = 0; + sal_uInt32 nRight = getEntryCount(); + + while (nRight - nLeft > 1) + { + sal_uInt32 nMiddle = (nLeft + nRight) / 2; + Fc aFcMiddle = getFc(nMiddle); + + if (! (rFc < aFcMiddle)) + { + nLeft = nMiddle; + } + else + { + nRight = nMiddle; + } + } + + return nLeft; +} +#else +sal_uInt32 WW8FKPImpl::getIndex(const Fc & rFc) const +{ + sal_uInt32 nResult = getEntryCount(); + + while (rFc < getFc(nResult)) + nResult--; + + return nResult; +} +#endif + + +writerfilter::Reference<Properties>::Pointer_t WW8CHPFKPImpl::getProperties(const Fc & rFc) const +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + sal_uInt32 n = getIndex(rFc); + + sal_uInt16 nOffset = 2 * getU8(getRgb() + n); + + if (nOffset > getRgb() + getEntryCount()) + { + sal_uInt16 nCbChpx = getU8(nOffset); + + if (nCbChpx > 1 && nOffset + nCbChpx + 1 <= 511) + { + pResult = writerfilter::Reference<Properties>::Pointer_t + (new WW8PropertySetImpl(*this, nOffset + 1, nCbChpx)); + } + } +#if 0 + else + { + clog << "outsider!!!" << endl; + } +#endif + + return pResult; +} + +void WW8CHPFKPImpl::dump(OutputWithDepth<string> & o) const +{ + o.addItem("<fkp type='CHP'>"); + + sal_uInt32 nCount = getEntryCount(); + for (sal_uInt32 n = 0; n < nCount; ++n) + { + char sBuffer[256]; + + snprintf(sBuffer, sizeof(sBuffer), + "<fkpentry fc='%" SAL_PRIxUINT32 "' offsetInFkp='%x'/>", + getFc(n).get(), 2 * getU8(getRgb() + n)); + + o.addItem(sBuffer); + } + + WW8StructBase::dump(o); + o.addItem("</fkp>"); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8PAPFKPImpl::getProperties(const Fc & rFc) const +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + sal_uInt32 n = getIndex(rFc); + + sal_uInt16 nOffset = 2 * getU8(getRgb() + n * 13); + + if (nOffset != 0) + { + if (nOffset > getRgb() + getEntryCount() * 13) + { + sal_uInt32 nOffsetIStd = nOffset + 1; + sal_uInt16 nCbPapx = getU8(nOffset) * 2; + + if (nCbPapx == 0) + { + nOffsetIStd = nOffset + 2; + nCbPapx = getU8(nOffset + 1) * 2 + 2; + } + + sal_uInt32 nOffsetEnd = nOffset + nCbPapx; + //sal_uInt32 nOffsetSprms = nOffsetIStd + 2; + + if (nCbPapx > 1 && nOffset + nCbPapx <= 511) + { + pResult = writerfilter::Reference<Properties>::Pointer_t + (new WW8PropertySetImpl(*this, nOffsetIStd, + nOffsetEnd - nOffsetIStd, + true)); + } + } +#if 0 + else + { + clog << "outsider!!!" << endl; + } +#endif + } + + return pResult; +} + +void WW8PAPFKPImpl::dump(OutputWithDepth<string> & o) const +{ + o.addItem("<fkp type='PAP'>"); + + sal_uInt32 nCount = getEntryCount(); + for (sal_uInt32 n = 0; n < nCount; ++n) + { + char sBuffer[256]; + + snprintf(sBuffer, sizeof(sBuffer), + "<fkpentry fc='%" SAL_PRIxUINT32 "' offsetInFKP='%x'/>", + getFc(n).get(), 2 * getU8(getRgb() + n * 13)); + + o.addItem(sBuffer); + } + + WW8StructBase::dump(o); + + o.addItem("</fkp>"); +} + +bool operator < (const PageNumberAndFKP & rA, + const PageNumberAndFKP & rB) +{ + return rA.mnPageNumber < rB.mnPageNumber; +} + +WW8FKPCache::~WW8FKPCache() +{ +} + +WW8FKP::Pointer_t WW8FKPCacheImpl::get(sal_uInt32 nPageNumber, + bool bComplex) +{ + WW8FKP::Pointer_t pResult; + + PageNumbersAndFKPs::iterator aIt; + aIt = mPageNumbersAndFKPs.find + (PageNumberAndFKP(nPageNumber, WW8FKP::Pointer_t())); + + if (aIt != mPageNumbersAndFKPs.end()) + pResult = aIt->getFKP(); + else + { + if (mPageNumbersAndFKPs.size() > mnCacheSize) + { + PageNumbersAndFKPs::iterator aItDel = + mPageNumbersAndFKPs.find + (PageNumberAndFKP(mPageNumbers.front(), + WW8FKP::Pointer_t())); + + mPageNumbersAndFKPs.erase(aItDel); + mPageNumbers.pop_front(); + } + + pResult = createFKP(nPageNumber, bComplex); + + PageNumberAndFKP aPageNumberAndFKP(nPageNumber, pResult); + mPageNumbersAndFKPs.insert(aPageNumberAndFKP); + mPageNumbers.push_back(nPageNumber); + } + + return pResult; +} + +WW8FKP::Pointer_t WW8CHPFKPCacheImpl::createFKP(sal_uInt32 nPageNumber, + bool bComplex) +{ + return WW8FKP::Pointer_t(new WW8CHPFKPImpl + (*mpStream, nPageNumber, bComplex)); +} + +WW8FKP::Pointer_t WW8PAPFKPCacheImpl::createFKP(sal_uInt32 nPageNumber, + bool bComplex) +{ + return WW8FKP::Pointer_t(new WW8PAPFKPImpl + (*mpStream, nPageNumber, bComplex)); +} +}} diff --git a/writerfilter/source/doctok/WW8FKPImpl.hxx b/writerfilter/source/doctok/WW8FKPImpl.hxx new file mode 100644 index 000000000000..a7e59a33b1b2 --- /dev/null +++ b/writerfilter/source/doctok/WW8FKPImpl.hxx @@ -0,0 +1,214 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_FKP_IMPL_HXX +#define INCLUDED_WW8_FKP_IMPL_HXX + +#include <set> +#include <deque> +#include <WW8FKP.hxx> + +#ifndef INCLUDED_OUTPUT_WITH_DEPTH_HXX +#include <resourcemodel/OutputWithDepth.hxx> +#endif + +namespace writerfilter { +namespace doctok +{ +/** + Implementation class for formatted disk pages. + */ +class WW8FKPImpl : public WW8FKP +{ + sal_uInt32 mnPageNumber; + bool mbComplex; + +public: + WW8FKPImpl(WW8Stream & rStream, sal_uInt32 nPageNumber, bool bComplex) + : WW8FKP(rStream, nPageNumber * 512), mnPageNumber(nPageNumber), + mbComplex(bComplex) + { + } + + virtual sal_uInt32 getPageNumber() const { return mnPageNumber; } + + virtual sal_uInt32 getEntryCount() const { return getU8(511); } + virtual sal_uInt32 getRgb() const { return 4 * (getEntryCount() + 1); } + virtual Fc getFc(sal_uInt32 nIndex) const + { return Fc(getU32(nIndex * 4), mbComplex); } + virtual Fc getFirstFc() const { return getFc(0); } + virtual Fc getLastFc() const { return getFc(getEntryCount()); } + + virtual bool contains(const Fc & rFc) const + { return getFirstFc() <= rFc && rFc < getLastFc(); } + + virtual sal_uInt32 getIndex(const Fc & rFc) const; + + friend bool operator < (const WW8FKPImpl & rA, + const WW8FKPImpl & rB); +}; + +/** + Implementation class for formatted disk pages containing character + properties. + */ +class WW8CHPFKPImpl : public WW8FKPImpl +{ +public: + WW8CHPFKPImpl(WW8Stream & rStream, sal_uInt32 nPageNumber, + bool bComplex) + : WW8FKPImpl(rStream, nPageNumber, bComplex) + { + } + + virtual writerfilter::Reference<Properties>::Pointer_t + getProperties(const Fc & rFc) const; + + virtual void dump(OutputWithDepth<string> & o) const; +}; + +/** + Implementation class for formatted disk pages containing paragraph + properties. + */ +class WW8PAPFKPImpl : public WW8FKPImpl +{ +public: + WW8PAPFKPImpl(WW8Stream & rStream, sal_uInt32 nPageNumber, + bool bComplex) + : WW8FKPImpl(rStream, nPageNumber, bComplex) + { + } + + virtual writerfilter::Reference<Properties>::Pointer_t + getProperties(const Fc & rFc) const; + + virtual void dump(OutputWithDepth<string> & o) const; +}; + +/** + Tuple of page number and formattet disk page. + */ +class PageNumberAndFKP +{ + /// page number + sal_uInt32 mnPageNumber; + + /// pointer to formatted disk page + WW8FKP::Pointer_t mpFKP; + +public: + PageNumberAndFKP(sal_uInt32 nPageNumber, WW8FKP::Pointer_t pFKP) + : mnPageNumber(nPageNumber), mpFKP(pFKP) + { + } + + /** + Return page number. + */ + sal_uInt32 getPageNumber() const { return mnPageNumber; } + + /** + Return formatted disk page. + */ + const WW8FKP::Pointer_t getFKP() const { return mpFKP; } + + friend bool operator < (const PageNumberAndFKP & rA, + const PageNumberAndFKP & rB); +}; + +/** + Cache for formatted disk pages. + */ +class WW8FKPCacheImpl : public WW8FKPCache +{ + /// size of the cache + sal_uInt32 mnCacheSize; + + /// set of tuples of page number and FKP + typedef set<PageNumberAndFKP> PageNumbersAndFKPs; + + /// + typedef deque<sal_uInt32> PageNumbers; + + PageNumbers mPageNumbers; + PageNumbersAndFKPs mPageNumbersAndFKPs; + +protected: + WW8Stream::Pointer_t mpStream; + virtual WW8FKP::Pointer_t createFKP(sal_uInt32 nPageNumber, + bool bComplex) = 0; + +public: + WW8FKPCacheImpl(WW8Stream::Pointer_t rpStream, sal_uInt32 nCacheSize) + : mnCacheSize(nCacheSize), mpStream(rpStream) + { + } + + virtual ~WW8FKPCacheImpl() + { + } + + WW8FKP::Pointer_t get(sal_uInt32 nPageNumber, bool bComplex); +}; + +class WW8CHPFKPCacheImpl : public WW8FKPCacheImpl +{ + virtual WW8FKP::Pointer_t createFKP(sal_uInt32 nPageNumber, + bool bComplex); + +public: + WW8CHPFKPCacheImpl(WW8Stream::Pointer_t rpStream, + sal_uInt32 nCacheSize) + : WW8FKPCacheImpl(rpStream, nCacheSize) + { + } + + virtual ~WW8CHPFKPCacheImpl() + { + } +}; + +class WW8PAPFKPCacheImpl : public WW8FKPCacheImpl +{ + virtual WW8FKP::Pointer_t createFKP(sal_uInt32 nPageNumber, + bool bComplex); + +public: + WW8PAPFKPCacheImpl(WW8Stream::Pointer_t rpStream, + sal_uInt32 nCacheSize) + : WW8FKPCacheImpl(rpStream, nCacheSize) + { + } + + virtual ~WW8PAPFKPCacheImpl() + { + } +}; +}} + +#endif // INCLUDED_WW8_FKP_IMPL_HXX diff --git a/writerfilter/source/doctok/WW8FontTable.cxx b/writerfilter/source/doctok/WW8FontTable.cxx new file mode 100644 index 000000000000..7391763f347e --- /dev/null +++ b/writerfilter/source/doctok/WW8FontTable.cxx @@ -0,0 +1,113 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> + +namespace writerfilter { +namespace doctok { + +void WW8FontTable::initPayload() +{ + sal_uInt32 nCount = getU8(0); + + sal_uInt32 nOffset = 1; + + while (nCount > 0) + { + entryOffsets.push_back(nOffset); + + sal_uInt32 nFFNSize = getU8(nOffset) + 1; + + if (nFFNSize > 1) + nCount--; + + nOffset += nFFNSize; + } + + entryOffsets.push_back(nOffset); + mnPlcfPayloadOffset = nOffset; +} + +sal_uInt32 WW8FontTable::getEntryCount() +{ + return entryOffsets.size() - 1; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8FontTable::getEntry(sal_uInt32 nIndex) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + sal_uInt32 nCount = entryOffsets[nIndex + 1] - entryOffsets[nIndex]; + + if (nCount > 1) + { + WW8Font * pFont = new WW8Font(this, + entryOffsets[nIndex], nCount); + + pFont->setIndex(nIndex); + + pResult = writerfilter::Reference<Properties>::Pointer_t(pFont); + } + + return pResult; +} + +sal_uInt32 WW8Font::get_f() +{ + return mnIndex; +} + +rtl::OUString WW8Font::get_xszFfn() +{ + sal_uInt32 nOffset = 0x28; + sal_uInt32 nCount = get_cbFfnM1() - nOffset; + + Sequence aSeq(mSequence, nOffset, nCount); + + rtl_uString * pNew = 0; + rtl_uString_newFromStr + (&pNew, reinterpret_cast<const sal_Unicode *>(&aSeq[0])); + + return rtl::OUString(pNew); +} + +rtl::OUString WW8Font::get_altName() +{ + sal_uInt32 nOffset = 0x28 + get_ixchSzAlt(); + sal_uInt32 nCount = get_cbFfnM1() - nOffset; + + Sequence aSeq(mSequence, nOffset, nCount); + + rtl_uString * pNew = 0; + rtl_uString_newFromStr + (&pNew, reinterpret_cast<const sal_Unicode *>(&aSeq[0])); + + return rtl::OUString(pNew); +} + +}} diff --git a/writerfilter/source/doctok/WW8LFOTable.cxx b/writerfilter/source/doctok/WW8LFOTable.cxx new file mode 100644 index 000000000000..1197ef7f190d --- /dev/null +++ b/writerfilter/source/doctok/WW8LFOTable.cxx @@ -0,0 +1,128 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include "resources.hxx" + +namespace writerfilter { +namespace doctok { + +void WW8LFOTable::initPayload() +{ + sal_uInt32 nCount = getEntryCount(); + + sal_uInt32 nOffset = 4; + sal_uInt32 nOffsetLFOData = mnPlcfPayloadOffset; + + for (sal_uInt32 n = 0; n < nCount; ++n) + { + WW8LFO aLFO(this, nOffset); + + entryOffsets.push_back(nOffset); + nOffset += WW8LFO::getSize(); + + payloadOffsets.push_back(nOffsetLFOData); + payloadIndices.push_back(n); + + nOffsetLFOData += 4; + + sal_uInt32 nLvls = aLFO.get_clfolvl(); + + for (sal_uInt32 k = 0; k < nLvls; ++k) + { + WW8LFOLevel aLevel(this, nOffsetLFOData); + nOffsetLFOData += aLevel.calcSize(); + } + } + + entryOffsets.push_back(nOffset); + payloadOffsets.push_back(nOffsetLFOData); +} + +sal_uInt32 WW8LFOTable::getEntryCount() +{ + return getU32(0); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8LFOTable::getEntry(sal_uInt32 nIndex) +{ + WW8LFO * pLFO = new WW8LFO(this, entryOffsets[nIndex]); + + pLFO->setIndex(nIndex); + + return writerfilter::Reference<Properties>::Pointer_t(pLFO); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8LFO::get_LFOData() +{ + WW8LFOTable * pLFOTable = dynamic_cast<WW8LFOTable *>(mpParent); + sal_uInt32 nPayloadOffset = pLFOTable->getPayloadOffset(mnIndex); + sal_uInt32 nPayloadSize = pLFOTable->getPayloadSize(mnIndex); + + return writerfilter::Reference<Properties>::Pointer_t + (new WW8LFOData(mpParent, nPayloadOffset, nPayloadSize)); +} + +/* +writerfilter::Reference<Properties>::Pointer_t +WW8LFO::get_lfolevel(sal_uInt32 nIndex) +{ + WW8LFOTable * pLFOTable = dynamic_cast<WW8LFOTable *>(mpParent); + sal_uInt32 nPayloadIndex = pLFOTable->getPayloadIndex(mnIndex) + nIndex; + sal_uInt32 nPayloadOffset = pLFOTable->getPayloadOffset(nPayloadIndex); + sal_uInt32 nPayloadSize = pLFOTable->getPayloadSize(nPayloadIndex); + + return writerfilter::Reference<Properties>::Pointer_t + (new WW8LFOLevel(mpParent, nPayloadOffset, nPayloadSize)); +} +*/ + +void WW8LFOLevel::resolveNoAuto(Properties & /*rHandler*/) +{ + +} + +sal_uInt32 WW8LFOLevel::calcSize() +{ + sal_uInt32 nResult = WW8LFOLevel::getSize(); + + if (get_fFormatting()) + { + WW8ListLevel aLevel(mpParent, mnOffsetInParent + nResult); + + nResult += aLevel.calcSize(); + + sal_uInt32 nXstSize = mpParent->getU16(mnOffsetInParent + nResult); + + nResult += (nXstSize + 1) * 2; + } + + return nResult; +} + +}} diff --git a/writerfilter/source/doctok/WW8ListTable.cxx b/writerfilter/source/doctok/WW8ListTable.cxx new file mode 100644 index 000000000000..15ef3039d8da --- /dev/null +++ b/writerfilter/source/doctok/WW8ListTable.cxx @@ -0,0 +1,150 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> +#include <WW8ResourceModelImpl.hxx> + +namespace writerfilter { +namespace doctok { + +void WW8ListTable::initPayload() +{ + sal_uInt32 nCount = getEntryCount(); + + sal_uInt32 nOffset = 2; + sal_uInt32 nOffsetLevel = mnPlcfPayloadOffset; + for (sal_uInt32 n = 0; n < nCount; ++n) + { + WW8List aList(this, nOffset); + + entryOffsets.push_back(nOffset); + payloadIndices.push_back(payloadOffsets.size()); + nOffset += WW8List::getSize(); + + sal_uInt32 nLvlCount = aList.get_fSimpleList() ? 1 : 9; + + for (sal_uInt32 i = 0; i < nLvlCount; ++i) + { + WW8ListLevel aLevel(this, nOffsetLevel); + + payloadOffsets.push_back(nOffsetLevel); + + nOffsetLevel += aLevel.calcSize(); + } + + if (nOffsetLevel > getCount()) + { + nOffsetLevel = getCount(); + + break; + } + } + + payloadOffsets.push_back(nOffsetLevel); + entryOffsets.push_back(nOffset); +} + +sal_uInt32 WW8ListTable::getEntryCount() +{ + return getU16(0); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8ListTable::getEntry(sal_uInt32 nIndex) +{ + WW8List * pList = new WW8List(this, entryOffsets[nIndex]); + + pList->setIndex(nIndex); + + return writerfilter::Reference<Properties>::Pointer_t + (pList); +} + +sal_uInt32 WW8List::get_listlevel_count() +{ + if (get_fSimpleList()) + return 1; + + return 9; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8List::get_listlevel(sal_uInt32 nIndex) +{ + WW8ListTable * pListTable = dynamic_cast<WW8ListTable *>(mpParent); + sal_uInt32 nPayloadIndex = pListTable->getPayloadIndex(mnIndex) + nIndex; + sal_uInt32 nPayloadOffset = pListTable->getPayloadOffset(nPayloadIndex); + sal_uInt32 nPayloadSize = pListTable->getPayloadSize(nPayloadIndex); + + return writerfilter::Reference<Properties>::Pointer_t + (new WW8ListLevel(mpParent, nPayloadOffset, nPayloadSize)); +} + +::rtl::OUString WW8ListLevel::get_xst() +{ + sal_uInt32 nOffset = WW8ListLevel::getSize(); + + nOffset += get_cbGrpprlPapx(); + nOffset += get_cbGrpprlChpx(); + + return getString(nOffset); +} + +void WW8ListLevel::resolveNoAuto(Properties & rHandler) +{ + sal_uInt32 nOffset = getSize(); + + { + WW8PropertySet::Pointer_t pSet + (new WW8PropertySetImpl(*this, nOffset, get_cbGrpprlPapx())); + + WW8PropertiesReference aRef(pSet); + aRef.resolve(rHandler); + } + + nOffset += get_cbGrpprlPapx(); + + { + WW8PropertySet::Pointer_t pSet + (new WW8PropertySetImpl(*this, nOffset, get_cbGrpprlChpx())); + + WW8PropertiesReference aRef(pSet); + aRef.resolve(rHandler); + } +} + +sal_uInt32 WW8ListLevel::calcSize() +{ + sal_uInt32 nResult = WW8ListLevel::getSize(); + + nResult += get_cbGrpprlPapx(); + nResult += get_cbGrpprlChpx(); + nResult += 2 + getU16(nResult) * 2; + + return nResult; +} +}} diff --git a/writerfilter/source/doctok/WW8OutputWithDepth.cxx b/writerfilter/source/doctok/WW8OutputWithDepth.cxx new file mode 100644 index 000000000000..c795ec11bb56 --- /dev/null +++ b/writerfilter/source/doctok/WW8OutputWithDepth.cxx @@ -0,0 +1,49 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <iostream> +#include "WW8OutputWithDepth.hxx" + +namespace writerfilter { +namespace doctok +{ + +using namespace ::std; + +WW8OutputWithDepth::WW8OutputWithDepth() +: OutputWithDepth<string>("<tablegroup>", "</tablegroup>") +{ +} + +void WW8OutputWithDepth::output(const string & str) const +{ + cout << str << endl; +} + +WW8OutputWithDepth output; + +}} diff --git a/writerfilter/source/doctok/WW8OutputWithDepth.hxx b/writerfilter/source/doctok/WW8OutputWithDepth.hxx new file mode 100644 index 000000000000..2165abab4a65 --- /dev/null +++ b/writerfilter/source/doctok/WW8OutputWithDepth.hxx @@ -0,0 +1,53 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_OUTPUT_WITH_DEPTH +#define INCLUDED_WW8_OUTPUT_WITH_DEPTH + +#include <resourcemodel/OutputWithDepth.hxx> + +#include <string> + +using namespace ::std; + +namespace writerfilter { +namespace doctok +{ +class WW8OutputWithDepth : public OutputWithDepth<string> +{ +protected: + void output(const string & output) const; +public: + WW8OutputWithDepth(); + virtual ~WW8OutputWithDepth() { finalize(); } +}; + +extern WW8OutputWithDepth output; + +}} + +#endif // INCLUDED_WW8_OUTPUT_WITH_DEPTH diff --git a/writerfilter/source/doctok/WW8Picture.cxx b/writerfilter/source/doctok/WW8Picture.cxx new file mode 100644 index 000000000000..3e2f6d1ced25 --- /dev/null +++ b/writerfilter/source/doctok/WW8Picture.cxx @@ -0,0 +1,208 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> +#include <WW8DocumentImpl.hxx> + +namespace writerfilter { +namespace doctok +{ + +void WW8PICF::resolveNoAuto(Properties & rHandler) +{ + WW8Stream::Pointer_t pStream = getDocument()->getDataStream(); + + { + writerfilter::Reference<Properties>::Pointer_t pContent; + if (getDocument()->isPicData()) + { + WW8Value::Pointer_t pValue = createValue(get_ffdata()); + rHandler.attribute(NS_rtf::LN_ffdata, *pValue); + } + else + { + WW8Value::Pointer_t pValue = createValue(get_DffRecord()); + rHandler.attribute(NS_rtf::LN_DffRecord, *pValue); + } + } +} + +writerfilter::Reference<Properties>::Pointer_t +WW8PICF::get_DffRecord() +{ + writerfilter::Reference<Properties>::Pointer_t + pRet(new DffBlock(this, get_cbHeader(), getCount() - get_cbHeader(), + 0)); + return pRet; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8PICF::get_ffdata() +{ + writerfilter::Reference<Properties>::Pointer_t + pRet(new WW8FFDATA(this, get_cbHeader(), getCount() - get_cbHeader())); + + WW8StructBase::Pointer_t pStruct + (new WW8StructBase(this, get_cbHeader(), + getCount() - get_cbHeader())); + + pStruct->dump(output); + + return pRet; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8FSPA::get_shape() +{ + return getDocument()->getShape(get_spid()); +} + +void WW8FFDATA::resolveNoAuto(Properties & rHandler) +{ + WW8DocumentImpl * pDocument = getDocument(); + + if (pDocument != NULL) + { + WW8FLD::Pointer_t pFLD = pDocument->getCurrentFLD(); + WW8Value::Pointer_t pValue = createValue(pFLD->get_flt()); + + rHandler.attribute(NS_rtf::LN_FLT, *pValue); + + } +} + +sal_uInt32 WW8FFDATA::get_FLT() +{ + sal_uInt32 nResult = 0; + + WW8DocumentImpl * pDocument = getDocument(); + + if (pDocument != NULL) + { + WW8FLD::Pointer_t pFLD = pDocument->getCurrentFLD(); + + if (pFLD.get() != NULL) + nResult = pFLD->get_flt(); + } + + return nResult; +} + +static sal_uInt32 lcl_FFDATA_default_offset(WW8FFDATA & rRef) +{ + return 0xa + (rRef.getU16(0xa) + 2) * 2; +} + +static sal_uInt32 lcl_FFDATA_formatting_offset(WW8FFDATA & rRef) +{ + sal_uInt32 nResult = lcl_FFDATA_default_offset(rRef); + + switch (rRef.get_FLT()) + { + case 71: // forms checkbox + case 83: // forms listbox + nResult += 2; + break; + default: + nResult += (rRef.getU16(nResult) + 2) * 2; + break; + } + + return nResult;; +} + +static sal_uInt32 lcl_FFDATA_help_offset(WW8FFDATA & rRef) +{ + sal_uInt32 nResult = lcl_FFDATA_formatting_offset(rRef); + + nResult += (rRef.getU16(nResult) + 2) * 2; + + return nResult;; +} + +static sal_uInt32 lcl_FFDATA_tooltip_offset(WW8FFDATA & rRef) +{ + sal_uInt32 nResult = lcl_FFDATA_help_offset(rRef); + + nResult += (rRef.getU16(nResult) + 2) * 2; + + return nResult;; +} + +rtl::OUString WW8FFDATA::get_default() +{ + rtl::OUString sResult; + + sal_uInt32 nOffset = lcl_FFDATA_default_offset(*this); + switch (get_FLT()) + { + case 70: + sResult = getString(nOffset); + + break; + default: + break; + } + + return sResult; +} + +rtl::OUString WW8FFDATA::get_formatting() +{ + return getString(lcl_FFDATA_formatting_offset(*this)); +} + +rtl::OUString WW8FFDATA::get_help() +{ + return getString(lcl_FFDATA_help_offset(*this)); +} + +rtl::OUString WW8FFDATA::get_tooltip() +{ + rtl::OUString sResult; + + sResult = getString(lcl_FFDATA_tooltip_offset(*this)); + + return sResult; +} + +sal_uInt16 WW8FFDATA::get_checked() +{ + sal_uInt16 nResult = 0; + + switch (get_FLT()) + { + case 71: + nResult = getU16(lcl_FFDATA_default_offset(*this)); + break; + default: + break; + } + + return nResult; +} +}} diff --git a/writerfilter/source/doctok/WW8PieceTable.hxx b/writerfilter/source/doctok/WW8PieceTable.hxx new file mode 100644 index 000000000000..9e09dd448f88 --- /dev/null +++ b/writerfilter/source/doctok/WW8PieceTable.hxx @@ -0,0 +1,175 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_PIECE_TABLE_HXX +#define INCLUDED_WW8_PIECE_TABLE_HXX + +#include <sal/types.h> +#include <doctok/WW8Document.hxx> + +#include <boost/shared_ptr.hpp> +#include <iostream> + +namespace writerfilter { +namespace doctok { + +using namespace ::std; + +struct Cp; +struct Fc; +class CpAndFc; + +/** + The piece table of a Word document. + + The piece table associates character positions (CP) and File + character positions (FC). In a FC based view the piece table + defines intervals of FCs that contain consecutive text. + + CPs and FCs can be complex, i.e. the associated text is stored in + bytes. Otherwise the text encoding is UTF-16. + */ +class WW8PieceTable +{ +public: + virtual ~WW8PieceTable() {} + /** + Shared pointer to piece table + */ + typedef boost::shared_ptr<WW8PieceTable> Pointer_t; + + /** + Convert CP to FC. + + @param aCpIn CP to convert + + @return FC associated with CP + */ + virtual Fc cp2fc(const Cp & aCpIn) const = 0; + + /** + Convert FC to CP. + + @param aFcIn FC to convert + + @return CP associated with FC + */ + virtual Cp fc2cp(const Fc & aFcIn) const = 0; + + /** + Check if CP is complex. + + @param aCp CP to check + @retval true CP is complex + @retval false else + */ + virtual bool isComplex(const Cp & aCp) const = 0; + + /** + Check if FC is complex. + + @param aFc FC to check + @retval true FC is complex + @retval false else + */ + virtual bool isComplex(const Fc & aFc) const = 0; + + /** + Return number of entries. + */ + virtual sal_uInt32 getCount() const = 0; + + /** + Return first CP. + */ + virtual Cp getFirstCp() const = 0; + + /** + Return first FC. + */ + virtual Fc getFirstFc() const = 0; + + /** + Return last CP. + */ + virtual Cp getLastCp() const = 0; + + /** + Return last FC. + */ + virtual Fc getLastFc() const = 0; + + /** + Return CP at index. + + @param nIndex index of CP to return + */ + virtual Cp getCp(sal_uInt32 nIndex) const = 0; + + /** + Return FC at index. + + @param nIndex index of FC to return + */ + virtual Fc getFc(sal_uInt32 nIndex) const = 0; + + /** + Create CpAndFc from Cp. + + @param rCp the Cp + + @return CpAndFc containing rCp and corresponding Fc + */ + virtual CpAndFc createCpAndFc(const Cp & rCp, PropertyType eType) const = 0; + + /** + Create CpAndFc from Fc. + + @param rFc the Fc + + @return CpAndFc containing rFc and corresponding Cp + */ + virtual CpAndFc createCpAndFc(const Fc & rFc, PropertyType eType) const = 0; + + /** + Dump piece table. + + @param o stream to dump to + */ + virtual void dump(ostream & o) const = 0; +}; + +/** + Dump piece table. + + @param o stream to dump to + @param rPieceTable piece table to dump +*/ +ostream & operator << (ostream & o, const WW8PieceTable & rPieceTable); +}} + +#endif // INCLUDED_WW8_PIECE_TABLE_HXX diff --git a/writerfilter/source/doctok/WW8PieceTableImpl.cxx b/writerfilter/source/doctok/WW8PieceTableImpl.cxx new file mode 100644 index 000000000000..869964aac67e --- /dev/null +++ b/writerfilter/source/doctok/WW8PieceTableImpl.cxx @@ -0,0 +1,299 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <algorithm> +#include <iterator> + +#ifndef INCLUDED_DOCTOK_EXCEPTIONS +#include <resourcemodel/exceptions.hxx> +#endif +#include <WW8PieceTableImpl.hxx> +#include <WW8Clx.hxx> + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +ostream & operator << (ostream & o, const WW8PieceTable & rPieceTable) +{ + rPieceTable.dump(o); + + return o; +} + +WW8PieceTableImpl::WW8PieceTableImpl(WW8Stream & rStream, + sal_uInt32 nOffset, + sal_uInt32 nCount) +{ + WW8Clx aClx(rStream, nOffset, nCount); + + sal_uInt32 nPieceCount = aClx.getPieceCount(); + + if (nPieceCount > 0) + { + for (sal_uInt32 n = 0; n < nPieceCount; n++) + { + Cp aCp(aClx.getCp(n)); + Fc aFc(aClx.getFc(n), aClx.isComplexFc(n)); + + CpAndFc aCpAndFc(aCp, aFc, PROP_DOC); + + mEntries.push_back(aCpAndFc); + } + + CpAndFc aBack = mEntries.back(); + Cp aCp(aClx.getCp(aClx.getPieceCount())); + Fc aFc(aBack.getFc() + (aCp - aBack.getCp())); + + CpAndFc aCpAndFc(aCp, aFc, PROP_DOC); + + mEntries.push_back(aCpAndFc); + } +} + +sal_uInt32 WW8PieceTableImpl::getCount() const +{ + return mEntries.size(); +} + +WW8PieceTableImpl::tEntries::const_iterator +WW8PieceTableImpl::findCp(const Cp & rCp) const +{ + tEntries::const_iterator aResult = mEntries.end(); + tEntries::const_iterator aEnd = mEntries.end(); + + for (tEntries::const_iterator aIt = mEntries.begin(); aIt != aEnd; + aIt++) + { + if (aIt->getCp() <= rCp) + { + aResult = aIt; + + //break; + } + } + + return aResult; +} + +WW8PieceTableImpl::tEntries::const_iterator +WW8PieceTableImpl::findFc(const Fc & rFc) const +{ + tEntries::const_iterator aResult = mEntries.end(); + tEntries::const_iterator aEnd = mEntries.end(); + + if (mEntries.size() > 0) + { + if (rFc < mEntries.begin()->getFc()) + aResult = mEntries.begin(); + else + { + for (tEntries::const_iterator aIt = mEntries.begin(); + aIt != aEnd; aIt++) + { + if (aIt->getFc() <= rFc) + { + tEntries::const_iterator aItNext = aIt; + aItNext++; + + if (aItNext != aEnd) + { + sal_uInt32 nOffset = rFc.get() - aIt->getFc().get(); + sal_uInt32 nLength = aItNext->getCp() - aIt->getCp(); + + if (! aIt->isComplex()) + nLength *= 2; + + if (nOffset < nLength) + { + aResult = aIt; + + break; + } + } + + } + } + } + } + + return aResult; +} + +Cp WW8PieceTableImpl::getFirstCp() const +{ + Cp aResult; + + if (getCount() > 0) + aResult = getCp(0); + else + throw ExceptionNotFound("WW8PieceTableImpl::getFirstCp"); + + return aResult; +} + +Fc WW8PieceTableImpl::getFirstFc() const +{ + Fc aResult; + + if (getCount() > 0) + aResult = getFc(0); + else + throw ExceptionNotFound(" WW8PieceTableImpl::getFirstFc"); + + return aResult; +} + +Cp WW8PieceTableImpl::getLastCp() const +{ + Cp aResult; + + if (getCount() > 0) + aResult = getCp(getCount() - 1); + else + throw ExceptionNotFound("WW8PieceTableImpl::getLastCp"); + + return aResult; +} + +Fc WW8PieceTableImpl::getLastFc() const +{ + Fc aResult; + + if (getCount() > 0) + aResult = getFc(getCount() - 1); + else + throw ExceptionNotFound("WW8PieceTableImpl::getLastFc"); + + return aResult; +} + +Cp WW8PieceTableImpl::getCp(sal_uInt32 nIndex) const +{ + return mEntries[nIndex].getCp(); +} + +Fc WW8PieceTableImpl::getFc(sal_uInt32 nIndex) const +{ + return mEntries[nIndex].getFc(); +} + +Cp WW8PieceTableImpl::fc2cp(const Fc & rFc) const +{ + Cp cpResult; + + if (mEntries.size() > 0) + { + Fc aFc; + + if (rFc < mEntries.begin()->getFc()) + aFc = mEntries.begin()->getFc(); + else + aFc = rFc; + + tEntries::const_iterator aIt = findFc(aFc); + + if (aIt != mEntries.end()) + { + cpResult = aIt->getCp() + (aFc - aIt->getFc()); + } + else + throw ExceptionNotFound("WW8PieceTableImpl::fc2cp: " + aFc.toString()); + } + + return cpResult; +} + +Fc WW8PieceTableImpl::cp2fc(const Cp & rCp) const +{ + Fc aResult; + + Cp2FcHashMap_t::iterator aItCp = mCp2FcCache.find(rCp); + + if (aItCp == mCp2FcCache.end()) + { + tEntries::const_iterator aIt = findCp(rCp); + + if (aIt != mEntries.end()) + { + aResult = aIt->getFc() + (rCp - aIt->getCp()); + mCp2FcCache[rCp] = aResult; + } + else + throw ExceptionNotFound + ("WW8PieceTableImpl::cp2fc: " + rCp.toString()); + } + else + aResult = mCp2FcCache[rCp]; + + return aResult; +} + +bool WW8PieceTableImpl::isComplex(const Cp & rCp) const +{ + bool bResult = false; + + tEntries::const_iterator aIt = findCp(rCp); + + if (aIt != mEntries.end()) + bResult = aIt->isComplex(); + + return bResult; +} + +bool WW8PieceTableImpl::isComplex(const Fc & rFc) const +{ + bool bResult = false; + + tEntries::const_iterator aIt = findFc(rFc); + + if (aIt != mEntries.end()) + bResult = aIt->isComplex(); + + return bResult; +} + +CpAndFc WW8PieceTableImpl::createCpAndFc +(const Cp & rCp, PropertyType eType) const +{ + return CpAndFc(rCp, cp2fc(rCp), eType); +} + +CpAndFc WW8PieceTableImpl::createCpAndFc +(const Fc & rFc, PropertyType eType) const +{ + return CpAndFc(fc2cp(rFc), rFc, eType); +} + +void WW8PieceTableImpl::dump(ostream & o) const +{ + o << "<piecetable>" << endl; + copy(mEntries.begin(), mEntries.end(), ostream_iterator<CpAndFc>(o, "\n")); + o << "</piecetable>" << endl; +} +}} diff --git a/writerfilter/source/doctok/WW8PieceTableImpl.hxx b/writerfilter/source/doctok/WW8PieceTableImpl.hxx new file mode 100644 index 000000000000..3d7a5e9ede79 --- /dev/null +++ b/writerfilter/source/doctok/WW8PieceTableImpl.hxx @@ -0,0 +1,75 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_PIECE_TABLE_IMPL_HXX +#define INCLUDED_WW8_PIECE_TABLE_IMPL_HXX + +#include <vector> +#include <WW8CpAndFc.hxx> +#ifndef INCLUDE_WW8_PIECE_TABLE_HXX +#include <WW8PieceTable.hxx> +#endif + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +class WW8PieceTableImpl : public WW8PieceTable +{ + typedef std::vector<CpAndFc> tEntries; + tEntries mEntries; + + tEntries::const_iterator findCp(const Cp & rCp) const; + tEntries::const_iterator findFc(const Fc & rFc) const; + + mutable Cp2FcHashMap_t mCp2FcCache; + +public: + WW8PieceTableImpl(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 nCount); + + virtual Fc cp2fc(const Cp & aCpIn) const; + virtual Cp fc2cp(const Fc & aFcIn) const; + virtual bool isComplex(const Cp & aCp) const; + virtual bool isComplex(const Fc & aFc) const; + + virtual sal_uInt32 getCount() const; + virtual Cp getFirstCp() const; + virtual Fc getFirstFc() const; + virtual Cp getLastCp() const; + virtual Fc getLastFc() const; + virtual Cp getCp(sal_uInt32 nIndex) const; + virtual Fc getFc(sal_uInt32 nIndex) const; + virtual CpAndFc createCpAndFc(const Cp & rCp, PropertyType eType) const; + virtual CpAndFc createCpAndFc(const Fc & rFc, PropertyType eType) const; + + virtual void dump(ostream & o) const; +}; +}} + +#endif // INCLUDED_WW8_PIECE_TABLE_IMPL_HXX diff --git a/writerfilter/source/doctok/WW8PropertySetImpl.cxx b/writerfilter/source/doctok/WW8PropertySetImpl.cxx new file mode 100644 index 000000000000..7b0cf28282c7 --- /dev/null +++ b/writerfilter/source/doctok/WW8PropertySetImpl.cxx @@ -0,0 +1,432 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include "WW8DocumentImpl.hxx" +#include "WW8ResourceModelImpl.hxx" +#include <doctok/resourceids.hxx> +#include <resourcemodel/QNameToString.hxx> + +namespace writerfilter { +namespace doctok +{ + + +bool operator != (const WW8PropertySetIterator & rA, + const WW8PropertySetIterator & rB) +{ + return ! (rA.equal(rB)); +} + +WW8Property::~WW8Property() +{ +} + +WW8PropertySet::~WW8PropertySet() +{ +} + +WW8PropertySetIterator::~WW8PropertySetIterator() +{ +} + +WW8PropertyImpl::WW8PropertyImpl(WW8Stream & rStream, + sal_uInt32 nOffset, sal_uInt32 nCount) +: WW8StructBase(rStream, nOffset, nCount) +{ +} + +WW8PropertyImpl::WW8PropertyImpl(const WW8StructBase & rBase, + sal_uInt32 nOffset, + sal_uInt32 nCount) +: WW8StructBase(rBase, nOffset, nCount) +{ +} + +WW8PropertyImpl::WW8PropertyImpl(WW8StructBase * pBase, + sal_uInt32 nOffset, + sal_uInt32 nCount) +: WW8StructBase(pBase, nOffset, nCount) +{ +} + +WW8PropertyImpl::~WW8PropertyImpl() +{ +} + +sal_uInt32 WW8PropertyImpl::getParam() const +{ + sal_uInt32 nResult = 0; + + switch (get_spra()) + { + case 0: + case 1: + nResult = getU8(2); + + break; + + case 2: + case 4: + case 5: + nResult = getU16(2); + + break; + + case 3: + nResult = getU32(2); + + break; + + case 7: + nResult = getU16(2) + (getU8(4) << 16); + + break; + + default: + break; + } + + return nResult; +} + +WW8Stream::Sequence WW8PropertyImpl::getParams() const +{ + return WW8Stream::Sequence(mSequence, 2, getCount() - 2); +} + +sal_uInt32 WW8PropertyImpl::getByteLength() const +{ + sal_uInt32 nParamSize = 0; + + switch (get_spra()) + { + case 0: + case 1: + nParamSize = 1; + + break; + + case 2: + case 4: + case 5: + nParamSize = 2; + + break; + + case 3: + nParamSize = 4; + + break; + + case 7: + nParamSize = 3; + + break; + default: + switch (getId()) + { + case 0xd608: + nParamSize = getU16(2) + 1; + break; + default: + nParamSize = getU8(2) + 1; + break; + } + + break; + } + + return nParamSize + 2; +} + +sal_uInt32 WW8PropertyImpl::getParamOffset() const +{ + sal_uInt32 nReturn = 0; + + if (get_spra() == 6) + nReturn = 1; + + switch (getId()) + { + case 0xd608: + case 0xd609: + nReturn = 3; + + break; + + default: + break; + } + + return nReturn; +} + +void WW8PropertyImpl::dump(OutputWithDepth<string> & o) const +{ + o.addItem(toString()); +} + +string WW8PropertyImpl::toString() const +{ + string aResult; + + aResult += "<sprmcommon"; + + char sBuffer[256]; + snprintf(sBuffer, sizeof(sBuffer), " id=\"%" SAL_PRIuUINT32 "\"", getId()); + aResult += sBuffer; + aResult += " name=\""; + aResult += (*SprmIdToString::Instance())(getId()); + aResult += "\""; + snprintf(sBuffer, sizeof(sBuffer), " sgc=\"%x\"", get_sgc()); + aResult += sBuffer; + snprintf(sBuffer, sizeof(sBuffer), " spra=\"%x\"", get_spra()); + aResult += sBuffer; + snprintf(sBuffer, sizeof(sBuffer), " size=\"%" SAL_PRIxUINT32 "\"", getByteLength()); + aResult += sBuffer; + snprintf(sBuffer, sizeof(sBuffer), " param=\"%" SAL_PRIxUINT32 "\"", getParam()); + aResult += sBuffer; + aResult += ">\n"; + + aResult += mSequence.toString(); + + aResult += "</sprmcommon>"; + + return aResult; +} + +WW8PropertySetImpl::WW8PropertySetImpl(WW8Stream & rStream, + sal_uInt32 nOffset, + sal_uInt32 nCount, + bool bPap) +: WW8StructBase(rStream, nOffset, nCount), mbPap(bPap) +{ +} + +WW8PropertySetImpl::WW8PropertySetImpl(const WW8StructBase & rBase, + sal_uInt32 nOffset, + sal_uInt32 nCount, + bool bPap) +: WW8StructBase(rBase, nOffset, nCount), mbPap(bPap) +{ +} + +WW8PropertySetImpl::~WW8PropertySetImpl() +{ +} + +bool WW8PropertySetImpl::isPap() const +{ + return mbPap; +} + +sal_uInt32 WW8PropertySetImpl::get_istd() const +{ + sal_uInt32 nResult = 0; + + if (mbPap) + nResult = getU16(0); + + return nResult; +} + +WW8PropertySetIterator::Pointer_t WW8PropertySetImpl::begin() +{ + return WW8PropertySetIterator::Pointer_t + (new WW8PropertySetIteratorImpl(this, mbPap ? 2 : 0)); +} + +WW8PropertySetIterator::Pointer_t WW8PropertySetImpl::end() +{ + return WW8PropertySetIterator::Pointer_t + (new WW8PropertySetIteratorImpl(this, getCount())); +} + +WW8PropertySetIteratorImpl::~WW8PropertySetIteratorImpl() +{ +} + +WW8Property::Pointer_t +WW8PropertySetImpl::getAttribute(sal_uInt32 nOffset) const +{ + WW8PropertyImpl aTmpAttr(*this, nOffset, 3); + + sal_uInt32 nLength = aTmpAttr.getByteLength(); + + if (nOffset + nLength > getCount()) + nLength = getCount() - nOffset; + + return WW8Property::Pointer_t + (new WW8PropertyImpl(*this, nOffset, nLength)); +} + +void WW8PropertySetImpl::dump(OutputWithDepth<string> & o) const +{ + WW8StructBase::dump(o); + + WW8PropertySetIterator::Pointer_t pIt = + const_cast<WW8PropertySetImpl *>(this)->begin(); + WW8PropertySetIterator::Pointer_t pItEnd = + const_cast<WW8PropertySetImpl *>(this)->end(); + + while((*pIt) != (*pItEnd)) + { + WW8Property::Pointer_t pAttr = pIt->get(); + + pAttr->dump(o); + ++(*pIt); + } +} + +void WW8PropertySetImpl::dots(ostream & o) +{ + WW8PropertySetIterator::Pointer_t pIt = begin(); + WW8PropertySetIterator::Pointer_t pItEnd = end(); + + while((*pIt) != (*pItEnd)) + { + WW8Property::Pointer_t pAttr = pIt->get(); + + o << "." << endl; + + ++(*pIt); + } +} + +string WW8PropertySetImpl::getType() const +{ + return "WW8PropertySetImpl"; +} + +void WW8PropertySetImpl::resolveLocal(Sprm & sprm, Properties & rHandler) +{ + switch (sprm.getId()) + { + case 0x6a03: + { + Value::Pointer_t pValue = sprm.getValue(); + getDocument()->setPicLocation(pValue->getInt()); + getDocument()->setPicIsData(false); + } + break; + case 0x806: + { + getDocument()->setPicIsData(true); + } + break; + case 0x6646: + { + WW8Stream::Pointer_t pStream = getDocument()->getDataStream(); + + if (pStream.get() != NULL) + { + Value::Pointer_t pValue = sprm.getValue(); + sal_uInt32 nOffset = pValue->getInt(); + WW8StructBase aStruct(*pStream, nOffset, 2); + sal_uInt16 nCount = aStruct.getU16(0); + + { + WW8PropertySetImpl * pPropSet = + new WW8PropertySetImpl(*pStream, nOffset + 2, nCount); + + pPropSet->resolve(rHandler); + } + } + } + break; + default: + break; + } +} + +void WW8PropertySetImpl::resolve(Properties & rHandler) +{ + if (getCount() >= (isPap() ? 5U : 3U)) + { + WW8PropertySetIterator::Pointer_t pIt = begin(); + WW8PropertySetIterator::Pointer_t pItEnd = end(); + + if (isPap()) + { + WW8Value::Pointer_t pValue = createValue(getU16(0)); + rHandler.attribute(NS_rtf::LN_ISTD, *pValue); + } + + while((*pIt) != (*pItEnd)) + { + WW8Sprm aSprm(pIt->get()); + + rHandler.sprm(aSprm); + + resolveLocal(aSprm, rHandler); + + ++(*pIt); + } + } +} + +WW8PropertySetIterator & WW8PropertySetIteratorImpl::operator++ () +{ + WW8Property::Pointer_t pTmpAttr = mpAttrSet->getAttribute(mnOffset); + + mnOffset += dynamic_cast<WW8PropertyImpl *>(pTmpAttr.get())-> + getByteLength(); + + if (mnOffset > mpAttrSet->getCount() || + mpAttrSet->getCount() - mnOffset < 3) + mnOffset = mpAttrSet->getCount(); + + return *this; +} + +WW8Property::Pointer_t WW8PropertySetIteratorImpl::get() const +{ + return mpAttrSet->getAttribute(mnOffset); +} + +bool WW8PropertySetIteratorImpl::equal +(const WW8PropertySetIterator & rIt) const +{ + const WW8PropertySetIteratorImpl & rMyIt = + dynamic_cast<const WW8PropertySetIteratorImpl &>(rIt); + + return mpAttrSet == rMyIt.mpAttrSet && mnOffset == rMyIt.mnOffset; +} + +string WW8PropertySetIteratorImpl::toString() const +{ + string sResult = ""; + + char sBuffer[256]; + + snprintf(sBuffer, sizeof(sBuffer), "(%" SAL_PRIuUINT32 ")", mnOffset); + sResult += sBuffer; + + return sResult; +} + +}} diff --git a/writerfilter/source/doctok/WW8PropertySetImpl.hxx b/writerfilter/source/doctok/WW8PropertySetImpl.hxx new file mode 100644 index 000000000000..2f7bb0f34708 --- /dev/null +++ b/writerfilter/source/doctok/WW8PropertySetImpl.hxx @@ -0,0 +1,145 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_PROPERTY_SET_IMPL_HXX +#define INCLUDED_WW8_PROEPRTY_SET_IMPL_HXX + +#include <resourcemodel/WW8ResourceModel.hxx> +#include <doctok/WW8Document.hxx> +#include <WW8StructBase.hxx> +#include <WW8OutputWithDepth.hxx> + +#include <map> + +namespace writerfilter { +namespace doctok +{ + +class WW8PropertyImpl : public WW8Property, public WW8StructBase +{ + sal_uInt8 get_ispmd() const + { return sal::static_int_cast<sal_uInt8>(getId() & 0xff); } + bool get_fSpec() const { return (getId() & 0x100) != 0; } + sal_uInt8 get_sgc() const + { return sal::static_int_cast<sal_uInt8>((getId() >> 10) & 0x7); } + sal_uInt8 get_spra() const + { return sal::static_int_cast<sal_uInt8>((getId() >> 13) & 0x7); } + +public: + WW8PropertyImpl(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount); + WW8PropertyImpl(const WW8StructBase & rBase, sal_uInt32 nOffset, + sal_uInt32 nCount); + + WW8PropertyImpl(WW8StructBase * pBase, sal_uInt32 nOffset, + sal_uInt32 nCount); + + virtual ~WW8PropertyImpl(); + + sal_uInt32 getId() const { return getU16(0); } + sal_uInt32 getParam() const; + WW8Stream::Sequence getParams() const; + + sal_uInt32 getByteLength() const; + sal_uInt32 getParamOffset() const; + + virtual void dump(OutputWithDepth<string> & o) const; + string toString() const; +}; + +class WW8PropertySetImpl : public WW8PropertySet, public WW8StructBase, + public ::writerfilter::Reference<Properties> +{ + bool mbPap; + +public: + typedef boost::shared_ptr<WW8PropertySet> Pointer_t; + + WW8PropertySetImpl(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 nCount, bool bPap = false); + + WW8PropertySetImpl(const WW8StructBase & rBase, sal_uInt32 nOffset, + sal_uInt32 nCount, bool bPap = false); + + virtual ~WW8PropertySetImpl(); + + virtual WW8PropertySetIterator::Pointer_t begin(); + virtual WW8PropertySetIterator::Pointer_t end(); + + virtual void dump(OutputWithDepth<string> & o) const; + virtual void dots(ostream & o); + + virtual string getType() const; + + virtual WW8Property::Pointer_t getAttribute(sal_uInt32 nOffset) const; + + virtual bool isPap() const; + virtual sal_uInt32 get_istd() const; + + virtual void insert(const WW8PropertySet::Pointer_t /*pSet*/) {} + + virtual void resolve(Properties & rHandler); + + /** + Get and distribute information from sprm that is used + internally by the document. + + @param rSprm sprm to process + @param rHandler property handler to resolve huge papx (sprm 0x6646) to + */ + virtual void resolveLocal(Sprm & rSprm, Properties & rHandler); +}; + +class WW8PropertySetIteratorImpl : public WW8PropertySetIterator +{ + WW8PropertySetImpl * mpAttrSet; + sal_uInt32 mnOffset; + +public: + WW8PropertySetIteratorImpl(WW8PropertySetImpl * pAttrSet, + sal_uInt32 nOffset) + : mpAttrSet(pAttrSet), mnOffset(nOffset) + { + } + + virtual ~WW8PropertySetIteratorImpl(); + + virtual WW8PropertySetIterator & operator++(); + + virtual WW8Property::Pointer_t get() const; + + virtual bool equal(const WW8PropertySetIterator & rIt) const; + + virtual string toString() const; +}; + +::writerfilter::Reference<Properties>::Pointer_t createSprmProps +(WW8PropertyImpl & rProp); +::writerfilter::Reference<BinaryObj>::Pointer_t createSprmBinary +(WW8PropertyImpl & rProp); +}} + +#endif // INCLUDED_WW8_PROPERTY_SET_IMPL_HXX diff --git a/writerfilter/source/doctok/WW8ResourceModelImpl.cxx b/writerfilter/source/doctok/WW8ResourceModelImpl.cxx new file mode 100644 index 000000000000..da72435d5efb --- /dev/null +++ b/writerfilter/source/doctok/WW8ResourceModelImpl.cxx @@ -0,0 +1,500 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <WW8ResourceModelImpl.hxx> +#include <resources.hxx> +#include <WW8OutputWithDepth.hxx> +#include <resourcemodel/TableManager.hxx> +#include <rtl/string.hxx> +#include <resourcemodel/QNameToString.hxx> + +namespace writerfilter { + +namespace doctok +{ +using namespace ::std; + + +// ------- WW8TableDataHandler --------- + +typedef WW8PropertySet::Pointer_t TablePropsPointer_t; + +class WW8TableDataHandler : public TableDataHandler<string, + TablePropsPointer_t> +{ +public: + typedef boost::shared_ptr<WW8TableDataHandler> Pointer_t; + virtual void startTable(unsigned int nRows, unsigned int nDepth, + TablePropsPointer_t pProps); + virtual void endTable(); + virtual void startRow(unsigned int nCols, + TablePropsPointer_t pProps); + virtual void endRow(); + virtual void startCell(const string & start, TablePropsPointer_t pProps); + virtual void endCell(const string & end); +}; + +void WW8TableDataHandler::startTable(unsigned int nRows, unsigned int nDepth, + TablePropsPointer_t /*pProps*/) +{ + char sBuffer[256]; + + string tmpStr = "<tabledata.table rows=\""; + snprintf(sBuffer, sizeof(sBuffer), "%d", nRows); + tmpStr += sBuffer; + tmpStr += "\" depth=\""; + snprintf(sBuffer, sizeof(sBuffer), "%d", nDepth); + tmpStr += sBuffer; + tmpStr += "\">"; + + output.addItem(tmpStr); +} + +void WW8TableDataHandler::endTable() +{ + output.addItem("</tabledata.table>"); +} + +void WW8TableDataHandler::startRow +(unsigned int nCols, TablePropsPointer_t /*pProps*/) +{ + char sBuffer[256]; + + snprintf(sBuffer, sizeof(sBuffer), "%d", nCols); + string tmpStr = "<tabledata.row cells=\""; + tmpStr += sBuffer; + tmpStr += "\">"; + output.addItem(tmpStr); +} + +void WW8TableDataHandler::endRow() +{ + output.addItem("</tabledata.row>"); +} + +void WW8TableDataHandler::startCell(const string & start, + TablePropsPointer_t /*pProps*/) +{ + output.addItem("<tabledata.cell>"); + output.addItem(start); + output.addItem(", "); +} + +void WW8TableDataHandler::endCell(const string & end) +{ + output.addItem(end); + output.addItem("</tabledata.cell>"); +} + +// ----- WW8TableDataManager ------------------------------- + +class WW8TableManager : + public TableManager<string, TablePropsPointer_t> +{ + typedef TableDataHandler<string, TablePropsPointer_t> + TableDataHandlerPointer_t; + +public: + WW8TableManager(); + virtual ~WW8TableManager() {} + virtual void endParagraphGroup(); + virtual bool sprm(Sprm & rSprm); +}; + +WW8TableManager::WW8TableManager() +{ + TableDataHandler<string, TablePropsPointer_t>::Pointer_t pHandler(new WW8TableDataHandler()); + setHandler(pHandler); +} + +bool WW8TableManager::sprm(Sprm & rSprm) +{ + TableManager<string, TablePropsPointer_t>::sprm(rSprm); + output.setDepth(getTableDepthNew()); + return true; +} + +void WW8TableManager::endParagraphGroup() +{ + string tmpStr = "<tabledepth depth=\""; + char sBuffer[256]; + snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIdINT32, getTableDepthNew()); + tmpStr += sBuffer; + tmpStr += "\"/>"; + output.addItem(tmpStr); + TableManager<string, TablePropsPointer_t>::endParagraphGroup(); +} + +WW8TableManager gTableManager; + + +//-------- WW8TableReference ----------------------------------- + +void WW8TableReference::resolve(Table & /*rHandler*/) +{ + output.addItem("<table/>"); +} + +string WW8TableReference::getType() const +{ + return "WW8TableReference"; +} + +void WW8PropertiesReference::resolve(Properties & rHandler) +{ + if (mpPropSet != NULL) + { + //mpPropSet->dump(clog); + + if (mpPropSet->isPap()) + { + WW8IntValue aValue(mpPropSet->get_istd()); + + rHandler.attribute(NS_rtf::LN_ISTD, aValue); + } + + WW8PropertySetIterator::Pointer_t pIt = mpPropSet->begin(); + WW8PropertySetIterator::Pointer_t pItEnd = mpPropSet->end(); + + try + { + while (! pIt->equal(*pItEnd)) + { + WW8Sprm aSprm(pIt->get()); + rHandler.sprm(aSprm); + + ++(*pIt); + } + } + catch (ExceptionOutOfBounds e) + { + } + } +} + +string WW8PropertiesReference::getType() const +{ + return "WW8PropertiesReference"; +} + +WW8BinaryObjReference::WW8BinaryObjReference +(WW8StructBase & rParent, sal_uInt32 nOffset, sal_uInt32 nCount) +: WW8StructBase(rParent, nOffset, nCount) +{ +} + +WW8BinaryObjReference::WW8BinaryObjReference +(WW8StructBase * pParent, sal_uInt32 nOffset, sal_uInt32 nCount) +: WW8StructBase(pParent, nOffset, nCount) +{ +} + +WW8BinaryObjReference::WW8BinaryObjReference +(WW8StructBase * pParent) +: WW8StructBase(pParent, 0x0, pParent->getCount()) +{ +} + +WW8BinaryObjReference::WW8BinaryObjReference +(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount) +: WW8StructBase(rStream, nOffset, nCount) +{ +} + +writerfilter::Reference<BinaryObj>::Pointer_t +WW8BinaryObjReference::getBinary() +{ + return writerfilter::Reference<BinaryObj>::Pointer_t + (new WW8BinaryObjReference(*this)); +} + +void WW8BinaryObjReference::resolve(BinaryObj & rHandler) +{ + writerfilter::Reference<Properties>::Pointer_t pRef = + writerfilter::Reference<Properties>::Pointer_t(); + + if (getCount() > 0) + rHandler.data(get(0), getCount(), pRef); +} + +string WW8BinaryObjReference::getType() const +{ + return "WW8BinaryObjReference"; +} + +sal_uInt32 WW8Sprm::getId() const +{ + sal_uInt32 nResult = 0; + + if (mpProperty.get() != NULL) + nResult = mpProperty->getId(); + else if (mpBinary.get() != NULL) + nResult = NS_rtf::LN_blob; + + return nResult; +} + +string WW8Sprm::toString() const +{ + string sResult = ""; + + if (mpProperty.get() != NULL) + sResult = mpProperty->toString(); + + return sResult; +} + +Value::Pointer_t WW8Sprm::getValue() +{ + Value::Pointer_t pResult; + + if (mpProperty.get() != NULL) + pResult = Value::Pointer_t(createValue(mpProperty->getParam())); + + return pResult; +} + +writerfilter::Reference<BinaryObj>::Pointer_t WW8Sprm::getBinary() +{ + writerfilter::Reference<BinaryObj>::Pointer_t pResult; + + if (mpBinary.get() != NULL) + pResult = writerfilter::Reference<BinaryObj>::Pointer_t + (mpBinary->clone()); + else if (mpProperty.get() != NULL) + pResult = createSprmBinary + (dynamic_cast<WW8PropertyImpl &>(*(mpProperty.get()))); + + return pResult; +} + +writerfilter::Reference<Stream>::Pointer_t WW8Sprm::getStream() +{ + return writerfilter::Reference<Stream>::Pointer_t(); +} + +writerfilter::Reference<Properties>::Pointer_t WW8Sprm::getProps() +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + if (mpProperty.get() != NULL) + { + pResult = createSprmProps + (dynamic_cast<WW8PropertyImpl &>(*(mpProperty.get()))); + } + + return pResult; +} + +Sprm::Kind WW8Sprm::getKind() +{ + return SprmKind(getId()); +} + +string WW8Sprm::getName() const +{ + return (*SprmIdToString::Instance())(getId()); +} + +int WW8Value::getInt() const +{ + return 0; +} + +uno::Any WW8Value::getAny() const +{ + return uno::Any(); +} + +::rtl::OUString WW8Value::getString() const +{ + return ::rtl::OUString(); +} + +string WW8Value::toString() const +{ + return string(); +} + +writerfilter::Reference<Properties>::Pointer_t WW8Value::getProperties() +{ + return writerfilter::Reference<Properties>::Pointer_t(); +} + +writerfilter::Reference<Stream>::Pointer_t WW8Value::getStream() +{ + return writerfilter::Reference<Stream>::Pointer_t(); +} + +writerfilter::Reference<BinaryObj>::Pointer_t WW8Value::getBinary() +{ + return writerfilter::Reference<BinaryObj>::Pointer_t(); +} + +int WW8IntValue::getInt() const +{ + return mValue; +} + +::rtl::OUString WW8IntValue::getString() const +{ + return ::rtl::OUString::valueOf(static_cast<sal_Int32>(mValue)); +} + +uno::Any WW8IntValue::getAny() const +{ + uno::Any aResult; + + aResult <<= static_cast<sal_uInt32>(mValue); + + return aResult; +} + +string WW8IntValue::toString() const +{ + char sBuffer[255]; + + snprintf(sBuffer, sizeof(sBuffer), "%x", mValue); + + return string(sBuffer); +} + +WW8Value::Pointer_t createValue(int value) +{ + return WW8Value::Pointer_t(new WW8IntValue(value)); +} + +WW8Value::Pointer_t createValue(WW8Value::Pointer_t value) +{ + return value; +} + +int WW8StringValue::getInt() const +{ + return 0; +} + +::rtl::OUString WW8StringValue::getString() const +{ + return mString; +} + +uno::Any WW8StringValue::getAny() const +{ + uno::Any aResult; + + aResult <<= mString; + + return aResult; +} + +string WW8StringValue::toString() const +{ + string result; + + sal_uInt32 nCount = mString.getLength(); + for (sal_uInt32 n = 0; n < nCount; ++n) + { + if (mString[n] <= 0xff && isprint(mString[n])) + { + sal_Unicode nC = mString[n]; + + if (nC < 256) + result += sal::static_int_cast<char>(nC); + else + result += "."; + } + else + { + char sBuffer[64]; + + snprintf(sBuffer, sizeof(sBuffer), "\\u%04x", mString[n]); + result += sBuffer; + } + } + + return result; +} + +WW8Value::Pointer_t createValue(const rtl::OUString & rStr) +{ + return WW8Value::Pointer_t(new WW8StringValue(rStr)); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8PropertiesValue::getProperties() +{ + return mRef; +} + +string WW8PropertiesValue::toString() const +{ + return "properties"; +} + +writerfilter::Reference<Stream>::Pointer_t WW8StreamValue::getStream() +{ + return mRef; +} + +string WW8StreamValue::toString() const +{ + return "stream"; +} + +writerfilter::Reference<BinaryObj>::Pointer_t WW8BinaryObjValue::getBinary() +{ + return mRef; +} + +string WW8BinaryObjValue::toString() const +{ + return "binaryObj"; +} + +WW8Value::Pointer_t createValue +(writerfilter::Reference<Properties>::Pointer_t rRef) +{ + return WW8Value::Pointer_t(new WW8PropertiesValue(rRef)); +} + +WW8Value::Pointer_t createValue(writerfilter::Reference<Stream>::Pointer_t rRef) +{ + return WW8Value::Pointer_t(new WW8StreamValue(rRef)); +} + +WW8Value::Pointer_t createValue +(writerfilter::Reference<BinaryObj>::Pointer_t rRef) +{ + return WW8Value::Pointer_t(new WW8BinaryObjValue(rRef)); +} + + +} + +} + diff --git a/writerfilter/source/doctok/WW8ResourceModelImpl.hxx b/writerfilter/source/doctok/WW8ResourceModelImpl.hxx new file mode 100644 index 000000000000..d7eba5ba67a2 --- /dev/null +++ b/writerfilter/source/doctok/WW8ResourceModelImpl.hxx @@ -0,0 +1,318 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX +#define INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX + +#include <doctok/WW8Document.hxx> + +#ifndef INCLUDED_WW8_RESOURCE_MODEL_HXX +#include <resourcemodel/WW8ResourceModel.hxx> +#endif +#include <WW8StructBase.hxx> + +#ifndef INCLUDED_OUTPUT_WITH_DEPTH_HXX +#include <resourcemodel/OutputWithDepth.hxx> +#endif + +#include <map> + +namespace writerfilter { +namespace doctok +{ +using namespace ::std; + +class WW8PropertiesReference : public writerfilter::Reference<Properties> +{ + WW8PropertySet::Pointer_t mpPropSet; + +public: + + WW8PropertiesReference(WW8PropertySet::Pointer_t pPropSet) + : mpPropSet(pPropSet) + { + } + + ~WW8PropertiesReference() + { + } + + virtual void resolve(Properties & rHandler); + + virtual string getType() const; +}; + +class WW8TableReference : public writerfilter::Reference<Table> +{ +public: + WW8TableReference() + { + } + + ~WW8TableReference() + { + } + + virtual void resolve(Table & rHandler); + + virtual string getType() const; +}; + +class WW8BinaryObjReference : public writerfilter::Reference<BinaryObj>, + public WW8StructBase +{ +public: + typedef boost::shared_ptr<WW8BinaryObjReference> Pointer_t; + WW8BinaryObjReference(WW8Stream & rStream, sal_uInt32 nOffset, + sal_uInt32 nCount); + WW8BinaryObjReference(WW8StructBase & rParent, sal_uInt32 nOffset, + sal_uInt32 nCount); + WW8BinaryObjReference(WW8StructBase * pParent, sal_uInt32 nOffset, + sal_uInt32 nCount); + WW8BinaryObjReference(WW8StructBase * pParent); + + WW8BinaryObjReference() + : WW8StructBase(WW8StructBase::Sequence()) + { + } + + ~WW8BinaryObjReference() + { + } + + virtual writerfilter::Reference<BinaryObj>::Pointer_t getBinary(); + + virtual void resolve(BinaryObj & rHandler); + + virtual string getType() const; + + virtual WW8BinaryObjReference * clone() { return new WW8BinaryObjReference(*this); } +}; + +class WW8Sprm : public Sprm +{ + WW8Property::Pointer_t mpProperty; + WW8BinaryObjReference::Pointer_t mpBinary; + +public: + WW8Sprm(WW8Property::Pointer_t pProperty) + : mpProperty(pProperty) + { + } + + WW8Sprm(WW8BinaryObjReference::Pointer_t pBinary) + : mpBinary(pBinary) + { + } + + WW8Sprm() + { + } + + WW8Sprm(const WW8Sprm & rSprm) + : Sprm(rSprm), mpProperty(rSprm.mpProperty), mpBinary(rSprm.mpBinary) + { + } + + virtual ~WW8Sprm() + { + } + + virtual Value::Pointer_t getValue(); + virtual writerfilter::Reference<BinaryObj>::Pointer_t getBinary(); + virtual writerfilter::Reference<Stream>::Pointer_t getStream(); + virtual writerfilter::Reference<Properties>::Pointer_t getProps(); + virtual Kind getKind(); + + virtual sal_uInt32 getId() const; + virtual string toString() const; + virtual string getName() const; + + virtual WW8Sprm * clone() const { return new WW8Sprm(*this); } +}; + +class WW8Value : public Value +{ +public: + WW8Value() {} + virtual ~WW8Value() {} + + virtual string toString() const; + virtual int getInt() const; + virtual ::rtl::OUString getString() const; + virtual uno::Any getAny() const; + virtual writerfilter::Reference<Properties>::Pointer_t getProperties(); + virtual writerfilter::Reference<Stream>::Pointer_t getStream(); + virtual writerfilter::Reference<BinaryObj>::Pointer_t getBinary(); + virtual WW8Value * clone() const = 0; +}; + +class WW8IntValue : public WW8Value +{ + int mValue; +public: + WW8IntValue(int value) : mValue(value) {} + virtual ~WW8IntValue() {} + + virtual int getInt() const; + virtual ::rtl::OUString getString() const; + virtual uno::Any getAny() const; + + virtual string toString() const; + + virtual WW8Value * clone() const { return new WW8IntValue(*this); } +}; + +/** + Creates value from an integer. + + @param value integer to create value from. +*/ +WW8Value::Pointer_t createValue(int value); + +ostream & operator << (ostream & o, const WW8Value & rValue); + +class WW8StringValue : public WW8Value +{ + ::rtl::OUString mString; + +public: + WW8StringValue(::rtl::OUString string_) : mString(string_) {} + virtual ~WW8StringValue() {} + + virtual int getInt() const; + virtual ::rtl::OUString getString() const; + virtual uno::Any getAny() const; + + virtual string toString() const; + + virtual WW8Value * clone() const { return new WW8StringValue(*this); } +}; + +/** + Creates value from a string. + + @param rStr string to create value from. +*/ +WW8Value::Pointer_t createValue(const rtl::OUString & rStr); + +class WW8PropertiesValue : public WW8Value +{ + mutable writerfilter::Reference<Properties>::Pointer_t mRef; + +public: + WW8PropertiesValue(writerfilter::Reference<Properties>::Pointer_t rRef) + : mRef(rRef) + { + } + + virtual ~WW8PropertiesValue() + { + } + + virtual writerfilter::Reference<Properties>::Pointer_t getProperties(); + + virtual string toString() const; + + virtual WW8Value * clone() const { return new WW8PropertiesValue(mRef); } +}; + +class WW8StreamValue : public WW8Value +{ + mutable writerfilter::Reference<Stream>::Pointer_t mRef; + +public: + WW8StreamValue(writerfilter::Reference<Stream>::Pointer_t rRef) + : mRef(rRef) + { + } + + virtual ~WW8StreamValue() + { + } + + virtual writerfilter::Reference<Stream>::Pointer_t getStream(); + + virtual string toString() const; + + virtual WW8Value * clone() const { return new WW8StreamValue(mRef); } +}; + +/** + Creates value from a properties reference. + + @param rRef reference to create value from. +*/ +WW8Value::Pointer_t createValue(writerfilter::Reference<Properties>::Pointer_t rRef); + +/** + Creates value from another value. + + @param value the value to copy +*/ +WW8Value::Pointer_t createValue(WW8Value::Pointer_t value); + +/** + Creates value from a stream reference. + + @param rRef reference to the stream + */ +WW8Value::Pointer_t createValue(writerfilter::Reference<Stream>::Pointer_t rRef); + +class WW8BinaryObjValue : public WW8Value +{ + mutable writerfilter::Reference<BinaryObj>::Pointer_t mRef; + +public: + WW8BinaryObjValue(writerfilter::Reference<BinaryObj>::Pointer_t rRef) + : mRef(rRef) + { + } + + virtual ~WW8BinaryObjValue() + { + } + + virtual writerfilter::Reference<BinaryObj>::Pointer_t getBinary(); + + virtual string toString() const; + + virtual WW8Value * clone() const { return new WW8BinaryObjValue(mRef); } +}; + +/** + Creates value from a binary object reference. + + @param rRef reference to the stream + */ +WW8Value::Pointer_t createValue(writerfilter::Reference<BinaryObj>::Pointer_t rRef); + +Sprm::Kind SprmKind(sal_uInt32 sprmCode); + +}} + +#endif // INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX diff --git a/writerfilter/source/doctok/WW8StreamImpl.cxx b/writerfilter/source/doctok/WW8StreamImpl.cxx new file mode 100644 index 000000000000..585673bfa887 --- /dev/null +++ b/writerfilter/source/doctok/WW8StreamImpl.cxx @@ -0,0 +1,207 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <WW8StreamImpl.hxx> + +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/io/XSeekable.hpp> +#include <com/sun/star/io/XStream.hpp> +#include <com/sun/star/lang/XMultiComponentFactory.hpp> + +#include <doctokLoggers.hxx> + +namespace writerfilter { +namespace doctok +{ +using namespace ::com::sun::star; + +#ifdef DEBUG +TagLogger::Pointer_t debug_logger(TagLogger::getInstance("DEBUG")); +#endif + +WW8Stream::~WW8Stream() +{ +} + +WW8StreamImpl::WW8StreamImpl(uno::Reference<uno::XComponentContext> rContext, + uno::Reference<io::XInputStream> rStream) +: mrComponentContext(rContext), mrStream(rStream) +{ + xFactory = uno::Reference<lang::XMultiComponentFactory> + (mrComponentContext->getServiceManager()); + + uno::Sequence<uno::Any> aArgs( 1 ); + aArgs[0] <<= mrStream; + + xOLESimpleStorage = uno::Reference<container::XNameContainer> + (xFactory->createInstanceWithArgumentsAndContext + (::rtl::OUString::createFromAscii + ("com.sun.star.embed.OLESimpleStorage"), + aArgs, mrComponentContext ), + uno::UNO_QUERY ); + +} + +WW8StreamImpl::~WW8StreamImpl() +{ +} + +WW8Stream::Sequence WW8StreamImpl::get(sal_uInt32 nOffset, + sal_uInt32 nCount) const +{ + uno::Sequence<sal_Int8> aSequence; + + if (nCount > 0) + { + uno::Reference< io::XSeekable > xSeek( mrStream, uno::UNO_QUERY_THROW ); + + xSeek->seek(nOffset); + + sal_Int32 nRead = mrStream->readBytes(aSequence, nCount); + + Sequence aReturnSequence(const_cast<const sal_uInt8 *> + (reinterpret_cast<sal_uInt8 *> + (&(aSequence[0]))), nRead); + + return aReturnSequence; + } + + return WW8Stream::Sequence(); +} + +WW8Stream::Pointer_t WW8StreamImpl::getSubStream(const ::rtl::OUString & sId) +{ + WW8Stream::Pointer_t pResult; + + try + { + if (xOLESimpleStorage.is()) + { + if (xOLESimpleStorage->hasByName(sId)) + { + uno::Reference<io::XStream> xNewStream; + { + uno::Any aValue = xOLESimpleStorage->getByName(sId); + aValue >>= xNewStream; + } + + if (xNewStream.is()) + { + WW8Stream::Pointer_t + pNew(new WW8StreamImpl(mrComponentContext, + xNewStream->getInputStream())); + + pResult = pNew; + } + } + } + } + catch (...) + { + } + + if (pResult.get() == NULL) + throw ExceptionNotFound("Stream not found"); + + return pResult; +} + +string WW8StreamImpl::getSubStreamNames() const +{ + string sResult; + + if (xOLESimpleStorage.is()) + { + uno::Sequence<rtl::OUString> aSeq = xOLESimpleStorage->getElementNames(); + + for (sal_uInt32 n = 0; + n < sal::static_int_cast<sal_uInt32>(aSeq.getLength()); ++n) + { + rtl::OUString aOUStr = aSeq[n]; + + if (n > 0) + sResult += ", "; + +#if 0 + rtl::OString aOStr; + aOUStr.convertToString(&aOStr, RTL_TEXTENCODING_ASCII_US, + OUSTRING_TO_OSTRING_CVTFLAGS); + + + sResult += aOStr.getStr(); +#endif + char sBuffer[256]; + for (sal_uInt32 j = 0; + j < sal::static_int_cast<sal_uInt32>(aOUStr.getLength()); ++j) + { + if (isprint(aOUStr[j])) + { + sal_Unicode nC = aOUStr[j]; + + if (nC < 255) + sResult += sal::static_int_cast<char>(nC); + else + sResult += "."; + } + else + { + snprintf(sBuffer, sizeof(sBuffer), "\\u%x", aOUStr[j]); + sResult += sBuffer; + } + } + } + } + + return sResult; +} + +uno::Sequence<rtl::OUString> WW8StreamImpl::getSubStreamUNames() const +{ + return xOLESimpleStorage->getElementNames(); +} + +void WW8StreamImpl::dump(OutputWithDepth<string> & o) const +{ + o.addItem("<stream>"); + + Sequence aSeq; + sal_uInt32 nOffset = 0; + sal_uInt32 nStep = 16; + + do + { + aSeq = get(nOffset, nStep); + dumpLine(o, aSeq, nOffset, nStep); + + nOffset += nStep; + } + while (aSeq.getCount() == nStep); + + o.addItem("</stream>"); +} + +}} diff --git a/writerfilter/source/doctok/WW8StreamImpl.hxx b/writerfilter/source/doctok/WW8StreamImpl.hxx new file mode 100644 index 000000000000..2f1a0b0b234e --- /dev/null +++ b/writerfilter/source/doctok/WW8StreamImpl.hxx @@ -0,0 +1,65 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/io/XInputStream.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <doctok/WW8Document.hxx> +#ifndef INCLUDED_OUTPUT_WITH_DEPTH_HXX +#include <resourcemodel/OutputWithDepth.hxx> +#endif + +namespace writerfilter { +namespace doctok +{ +using namespace ::com::sun::star; + +class WW8StreamImpl : public WW8Stream +{ + uno::Reference<uno::XComponentContext> mrComponentContext; + uno::Reference<io::XInputStream> mrStream; + uno::Reference<container::XNameContainer> xOLESimpleStorage; + uno::Reference<lang::XMultiComponentFactory> xFactory; + +public: + WW8StreamImpl(uno::Reference<uno::XComponentContext> rContext, + uno::Reference<io::XInputStream> rStream); + virtual ~WW8StreamImpl(); + + virtual WW8Stream::Pointer_t getSubStream(const ::rtl::OUString & rId); + + virtual Sequence get(sal_uInt32 nOffset, sal_uInt32 nCount) + const; + + //virtual bool put(sal_uInt32 nOffset, const Sequence & rSeq); + + virtual string getSubStreamNames() const; + virtual uno::Sequence<rtl::OUString> getSubStreamUNames() const; + + virtual void dump(OutputWithDepth<string> & o) const; +}; +}} diff --git a/writerfilter/source/doctok/WW8StructBase.cxx b/writerfilter/source/doctok/WW8StructBase.cxx new file mode 100644 index 000000000000..746034f4b177 --- /dev/null +++ b/writerfilter/source/doctok/WW8StructBase.cxx @@ -0,0 +1,199 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <WW8StructBase.hxx> + +namespace writerfilter { +namespace doctok { +using namespace ::com::sun::star; + +WW8StructBase::WW8StructBase(const WW8StructBase & rParent, + sal_uInt32 nOffset, sal_uInt32 nCount) +: mSequence(rParent.mSequence, nOffset, nCount), mpParent(0), + mpDocument(rParent.getDocument()) +{ + if (nOffset + nCount > rParent.getCount()) + { + throw ExceptionOutOfBounds("WW8StructBase"); + } +} + +WW8StructBase & WW8StructBase::Assign(const WW8StructBase & rSrc) +{ + mSequence = rSrc.mSequence; + mpDocument = rSrc.mpDocument; + + return *this; +} + +void WW8StructBase::setDocument(WW8DocumentImpl * pDocument) +{ + mpDocument = pDocument; +} + +WW8DocumentImpl * WW8StructBase::getDocument() const +{ + return mpDocument; +} + +sal_uInt8 WW8StructBase::getU8(sal_uInt32 nOffset) const +{ + return doctok::getU8(mSequence, nOffset); +} + +sal_uInt16 WW8StructBase::getU16(sal_uInt32 nOffset) const +{ + return doctok::getU16(mSequence, nOffset); +} + +sal_uInt32 WW8StructBase::getU32(sal_uInt32 nOffset) const +{ + return doctok::getU32(mSequence, nOffset); +} + +sal_Bool WW8StructBase::getBit(sal_uInt32 nValue, sal_uInt16 nBit) const +{ + return (nValue & (1 << nBit)) != 0; +} + +sal_uInt8 WW8StructBase::getNibble(sal_uInt32 nValue, + sal_uInt16 nShift) const +{ + return sal::static_int_cast<sal_uInt8>((nValue >> nShift) & 0xf); +} + +sal_uInt8 getU8(const WW8StructBase::Sequence & rSeq, + sal_uInt32 nOffset) +{ + return rSeq[nOffset]; +} + +sal_uInt16 getU16(const WW8StructBase::Sequence & rSeq, + sal_uInt32 nOffset) +{ + return getU8(rSeq, nOffset) | (getU8(rSeq, nOffset + 1) << 8); +} + +sal_uInt32 getU32(const WW8StructBase::Sequence & rSeq, + sal_uInt32 nOffset) +{ + sal_uInt32 nResult = getU8(rSeq, nOffset); + nResult |= (getU8(rSeq, nOffset + 1) << 8); + nResult |= (getU8(rSeq, nOffset + 2) << 16); + nResult |= (getU8(rSeq, nOffset + 3) << 24); + + return nResult; +} + +rtl::OUString WW8StructBase::getString(sal_uInt32 nOffset, sal_uInt32 nCount) + const +{ + rtl::OUString aResult; + + if (nOffset < getCount()) + { + sal_uInt32 nCount1 = nCount; + if (nOffset + nCount * 2 > getCount()) + { + nCount1 = (getCount() - nOffset) / 2; + } + + if (nCount1 > 0) + { + Sequence aSeq(mSequence, nOffset, nCount1 * 2); + + rtl_uString * pNew = 0; + rtl_uString_newFromStr_WithLength + (&pNew, reinterpret_cast<const sal_Unicode *>(&aSeq[0]), + nCount1); + + aResult = rtl::OUString(pNew); + } + } + + return aResult; +} + +WW8StructBase * +WW8StructBase::getRemainder(sal_uInt32 nOffset) const +{ + WW8StructBase * pResult = NULL; + + sal_uInt32 nCount = getCount(); + if (nCount > nOffset) + { + pResult = new WW8StructBase(*this, nOffset, nCount - nOffset); + } + + return pResult; +} + + +rtl::OUString WW8StructBase::getString(sal_uInt32 nOffset) const +{ + sal_uInt32 nCount = getU16(nOffset); + + return getString(nOffset + 2, nCount); +} + +WW8StructBaseTmpOffset::WW8StructBaseTmpOffset +(WW8StructBase * pStructBase) +: mnOffset(0), mpStructBase(pStructBase) +{ +} + +sal_uInt32 WW8StructBaseTmpOffset::set(sal_uInt32 nOffset) +{ + if (nOffset >= mpStructBase->getCount()) + throw ExceptionOutOfBounds("WW8StructBaseTmpOffset::set"); + + mnOffset = nOffset; + + return mnOffset; +} + +sal_uInt32 WW8StructBaseTmpOffset::get() const +{ + return mnOffset; +} + +sal_uInt32 WW8StructBaseTmpOffset::inc(sal_uInt32 nOffset) +{ + if (mpStructBase->getCount() - mnOffset < nOffset) + throw ExceptionOutOfBounds("WW8StructBaseTmpOffset::inc"); + + mnOffset += nOffset; + + return mnOffset; +} + +WW8StructBaseTmpOffset::operator sal_uInt32() const +{ + return mnOffset; +} + +}} diff --git a/writerfilter/source/doctok/WW8StructBase.hxx b/writerfilter/source/doctok/WW8StructBase.hxx new file mode 100644 index 000000000000..0a1f7949fabf --- /dev/null +++ b/writerfilter/source/doctok/WW8StructBase.hxx @@ -0,0 +1,316 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_STRUCT_BASE_HXX +#define INCLUDED_WW8_STRUCT_BASE_HXX + +#include <boost/shared_ptr.hpp> +#include <doctok/WW8Document.hxx> +#include <resourcemodel/OutputWithDepth.hxx> + +namespace writerfilter { +namespace doctok { + +class WW8DocumentImpl; + +/** + Part of a stream. + + A part can have a parent, meaning its sequence of data is a + subsequence of its parent's sequence of data. + */ +class WW8StructBase +{ +public: + typedef SubSequence<sal_uInt8> Sequence; + typedef boost::shared_ptr<WW8StructBase> Pointer_t; + +protected: + /** + Stream this part was created from. + */ + ::com::sun::star::uno::Reference<com::sun::star::io:: + XInputStream> mrStream; + + /** + The data. + */ + mutable Sequence mSequence; + + /** + This part's parent. + */ + WW8StructBase * mpParent; + + /** + This part's offset in parent. + */ + sal_uInt32 mnOffsetInParent; + + /** + The document of this struct. + */ + WW8DocumentImpl * mpDocument; + +public: + WW8StructBase(sal_Int32 nLength) + : mSequence(nLength) + { + } + + /** + Creates a part from a steam. + + @param rStream the stream + @param nOffset offset in @a rStream to start at + @param nCount count of bytes in the new part + */ + WW8StructBase(WW8Stream & rStream, + sal_Int32 nOffset, sal_Int32 nCount) + : mSequence(rStream.get(nOffset, nCount)), mpParent(0), mpDocument(0) + { + } + + /** + Creates a part from a sequence. + + @param rSequence the sequence + @param nOffset offset in @a rSequence to start at + @param nCount count of bytes in the new part + */ + WW8StructBase(const Sequence & rSequence, sal_uInt32 nOffset = 0, + sal_uInt32 nCount = 0) + : mSequence(rSequence, nOffset, nCount), mpParent(0), mpDocument(0) + { + } + + /** + Creates a part from a parent part. + + @param pParent the parent + @param nOffset offset in @a pParent to start at + @param nCount count of bytes in the new part + */ + WW8StructBase(const WW8StructBase & rParent, + sal_uInt32 nOffset, sal_uInt32 nCount); + + /** + Creates a part from a parent part. + + @param pParent the parent + @param nOffset offset in @a pParent to start at + @param nCount count of bytes in the new part + */ + WW8StructBase(WW8StructBase * pParent, + sal_uInt32 nOffset, sal_uInt32 nCount) + : mSequence(pParent->mSequence, nOffset, nCount), mpParent(pParent), + mnOffsetInParent(nOffset), mpDocument(pParent->getDocument()) + { + if (nOffset + nCount > pParent->mSequence.getCount()) + throw ExceptionOutOfBounds("WW8StructBase"); + } + + + virtual ~WW8StructBase() + { + } + + /** + Assign a part to this part. + + After assignment this part has the same content as the assigned + part. + + @param rSrc part to assign + + @return this part after assignment + */ + virtual WW8StructBase & Assign(const WW8StructBase & rSrc); + + /** + Set the document of this struct. + */ + void setDocument(WW8DocumentImpl * pDocument); + + /** + Return the document of this struct. + */ + WW8DocumentImpl * getDocument() const; + + /** + Return count of bytes in this part. + */ + sal_uInt32 getCount() const { return mSequence.getCount(); } + + /** + Return unsigned byte value at an offset. + + @param offset offset to get value from + */ + sal_uInt8 getU8(sal_uInt32 nOffset) const; + + /** + Return unsigned 16-bit value at an offset. + + @param offset offset to get value from + */ + sal_uInt16 getU16(sal_uInt32 nOffset) const; + + /** + Return unsigned 32-bit value at an offset. + + @param offset offset to get value from + */ + sal_uInt32 getU32(sal_uInt32 nOffset) const; + + /** + Return signed 8-bit value at an offset. + + @param offset offset to get value from + */ + sal_Int8 getS8(sal_uInt32 nOffset) const + { return (sal_Int8) getU8(nOffset); } + + /** + Return signed 16-bit value at an offset. + + @param offset offset to get value from + */ + sal_Int16 getS16(sal_uInt32 nOffset) const + {return (sal_Int16) getU16(nOffset); } + + /** + Return signed 32-bit value at an offset. + + @param offset offset to get value from + */ + sal_Int32 getS32(sal_uInt32 nOffset) const + { return (sal_Int32) getU32(nOffset); } + + /** + Return bit value from a 32-bit unsigned value. + + @param nValue value to retreive bit from + @param nBit number of bit to retreive (0 = least significant) + */ + sal_Bool getBit(sal_uInt32 nValue, sal_uInt16 nBit) const; + + /** + Return nibble from a 32-bit unsigned value. + + @param nValue value to retreive nibble from (most significant bit left) + @param nShift amount of bits to shift right before returning least significant nibble + */ + sal_uInt8 getNibble(sal_uInt32 nValue, sal_uInt16 nShift) const; + + /** + Returns byte at an index. + + @param nIndex index in this part of the byte to return + */ + const sal_uInt8 * get(sal_uInt32 nIndex) const + { return &((mSequence.getSequence())[nIndex + mSequence.getOffset()]); } + + /** + Returns two byte character string starting at an offset. + + The string has to be Pascal like, e.g. the first word contains + the lengthof the string in characters and is followed by the + string's characters. + + @param nOffset offset the string starts at + + @return the string + */ + rtl::OUString getString(sal_uInt32 nOffset) const; + + /** + Returns binary object for remainder of this WW8StructBase + + @param nOffset offset where remainder starts + */ + WW8StructBase * getRemainder(sal_uInt32 nOffset) const; + + /** + Returns two byte character string starting at an offset with a + given length. + + @param nOffset offset the string starts at + @param nLength number of characters in the string + */ + rtl::OUString getString(sal_uInt32 nOffset, sal_uInt32) const; + + /** + Dump the part. + + @param o stream to dump to + */ + virtual void dump(OutputWithDepth<string> & o) const { mSequence.dump(o); } +}; + +class WW8StructBaseTmpOffset +{ + sal_uInt32 mnOffset; + WW8StructBase * mpStructBase; + +public: + WW8StructBaseTmpOffset(WW8StructBase * pStructBase); + + sal_uInt32 set(sal_uInt32 nOffset); + sal_uInt32 get() const; + sal_uInt32 inc(sal_uInt32 nOffset); + + operator sal_uInt32 () const; +}; + +/** + Return unsigned byte from a sequence. + + @param rSeq sequence to get value from + @param nOffset offset in sequence to get value from + */ +sal_uInt8 getU8(const WW8StructBase::Sequence & rSeq, sal_uInt32 nOffset); + +/** + Return unsigned 16-bit value from a sequence. + + @param rSeq sequence to get value from + @param nOffset offset in sequence to get value from + */ +sal_uInt16 getU16(const WW8StructBase::Sequence & rSeq, sal_uInt32 nOffset); + +/** + Return unsigned 32-bit value from a sequence. + + @param rSeq sequence to get value from + @param nOffset offset in sequence to get value from + */ +sal_uInt32 getU32(const WW8StructBase::Sequence & rSeq, sal_uInt32 nOffset); + +}} + +#endif // INCLUDED_WW8_STRUCT_BASE_HXX diff --git a/writerfilter/source/doctok/WW8Sttbf.cxx b/writerfilter/source/doctok/WW8Sttbf.cxx new file mode 100644 index 000000000000..36e2e805436d --- /dev/null +++ b/writerfilter/source/doctok/WW8Sttbf.cxx @@ -0,0 +1,168 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <WW8Sttbf.hxx> +#include <resources.hxx> + +namespace writerfilter { +namespace doctok +{ + +WW8Sttbf::WW8Sttbf(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount) +: WW8StructBase(rStream, nOffset, nCount) +{ + sal_uInt32 nComplexOffset = 0; + if (getU16(0) == 0xffff) + { + mbComplex = true; + nComplexOffset = 2; + } + + mnCount = getU16(nComplexOffset); + mnExtraDataCount = getU16(nComplexOffset + 2); + + nOffset = (mbComplex ? 2 : 0) + 4; + + for (sal_uInt32 n = 0; n < mnCount; ++n) + { + mEntryOffsets.push_back(nOffset); + + sal_uInt32 nStringLength = getU16(nOffset); + + nOffset += 2 + nStringLength * (mbComplex ? 2 : 1); + + mExtraOffsets.push_back(nOffset); + + nOffset += mnExtraDataCount; + } +} + +sal_uInt32 WW8Sttbf::getEntryOffset(sal_uInt32 nPos) const +{ + return mEntryOffsets[nPos]; +} + +sal_uInt32 WW8Sttbf::getExtraOffset(sal_uInt32 nPos) const +{ + return mExtraOffsets[nPos]; +} + +sal_uInt32 WW8Sttbf::getEntryCount() const +{ + return mnCount; +} + +rtl::OUString WW8Sttbf::getEntry(sal_uInt32 nPos) const +{ + return getString(getEntryOffset(nPos)); +} + +WW8StructBase::Pointer_t WW8Sttbf::getExtraData(sal_uInt32 nPos) +{ + return WW8StructBase::Pointer_t + (new WW8StructBase(*this, getExtraOffset(nPos), mnExtraDataCount)); +} + +WW8SttbTableResource::WW8SttbTableResource(WW8Sttbf::Pointer_t pSttbf) +: mpSttbf(pSttbf) +{ +} + +WW8SttbTableResource::~WW8SttbTableResource() +{ +} + +void WW8SttbTableResource::resolve(Table & rTable) +{ + sal_uInt32 nCount = mpSttbf->getEntryCount(); + + for (sal_uInt32 n = 0; n < nCount; n++) + { + WW8StringValue::Pointer_t pVal(new WW8StringValue(mpSttbf->getEntry(n))); + ::writerfilter::Reference<Properties>::Pointer_t pProps(new WW8StringProperty(0, pVal)); + + rTable.entry(n, pProps); + } +} + +string WW8SttbTableResource::getType() const +{ + return "WW8SttbTableResource"; +} + +WW8StringProperty::WW8StringProperty(sal_uInt32 nId, WW8StringValue::Pointer_t pValue) +: mnId(nId), mpValue(pValue) +{ +} + +WW8StringProperty::~WW8StringProperty() +{ +} + +void WW8StringProperty::resolve(Properties & rProperties) +{ + rProperties.attribute(mnId, *mpValue); +} + +string WW8StringProperty::getType() const +{ + return "WW8StringProperty"; +} + +sal_uInt32 WW8SttbRgtplc::getEntryCount() +{ + return getU16(2); +} + +::writerfilter::Reference<Properties>::Pointer_t +WW8SttbRgtplc::getEntry(sal_uInt32 nIndex) +{ + ::writerfilter::Reference<Properties>::Pointer_t pResult; + + sal_uInt32 nOffset = 6; + + while (nIndex > 0) + { + sal_uInt16 nCount = getU16(nOffset); + + nOffset = nOffset + 2 + nCount; + ++nIndex; + } + + sal_uInt16 nCount = getU16(nOffset); + + if (nCount > 0) + { + WW8Tplc * pTplc = new WW8Tplc(*this, nOffset + 2, nCount); + + pResult.reset(pTplc); + } + + return pResult; +} + +}} diff --git a/writerfilter/source/doctok/WW8Sttbf.hxx b/writerfilter/source/doctok/WW8Sttbf.hxx new file mode 100644 index 000000000000..5c82d94723a9 --- /dev/null +++ b/writerfilter/source/doctok/WW8Sttbf.hxx @@ -0,0 +1,132 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_WW8_STTBF_HXX +#define INCLUDED_WW8_STTBF_HXX + +#include <WW8StructBase.hxx> +#include <WW8ResourceModelImpl.hxx> + +#include <boost/shared_ptr.hpp> +#include <vector> + +namespace writerfilter { +namespace doctok +{ + +using namespace ::std; + +/** + A string table in file. + + The string table contains strings that each can have extra data. + */ +class WW8Sttbf : public WW8StructBase +{ + /// true if strings contain two-byte characters + bool mbComplex; + + /// the number of entries + sal_uInt32 mnCount; + + /// the size of the extra data (per string) + sal_uInt32 mnExtraDataCount; + + /// offsets for the strings + vector<sal_uInt32> mEntryOffsets; + + /// offsets for the extra data + vector<sal_uInt32> mExtraOffsets; + + /** + Return offset of an entry. + + @param nPos the index of the entry + */ + sal_uInt32 getEntryOffset(sal_uInt32 nPos) const; + + /** + Return offset of extra data of an entry. + + @param nPos the index of the entry + */ + sal_uInt32 getExtraOffset(sal_uInt32 nPos) const; + +public: + typedef boost::shared_ptr<WW8Sttbf> Pointer_t; + + WW8Sttbf(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount); + + /** + Return the number of entries. + */ + sal_uInt32 getEntryCount() const; + + /** + Return the string of an entry. + + @param nPos the index of the entry + */ + rtl::OUString getEntry(sal_uInt32 nPos) const; + + /** + Return the extra data of an entry. + + @param nPos the index of the entry + */ + WW8StructBase::Pointer_t getExtraData(sal_uInt32 nPos); +}; + +class WW8SttbTableResource : public ::writerfilter::Reference<Table> +{ + WW8Sttbf::Pointer_t mpSttbf; + +public: + WW8SttbTableResource(WW8Sttbf::Pointer_t pSttbf); + virtual ~WW8SttbTableResource(); + + void resolve(Table & rTable); + + string getType() const; +}; + +class WW8StringProperty : public ::writerfilter::Reference<Properties> +{ + sal_uInt32 mnId; + WW8StringValue::Pointer_t mpValue; + +public: + WW8StringProperty(sal_uInt32 nId, WW8StringValue::Pointer_t pValue); + virtual ~WW8StringProperty(); + + void resolve(Properties & rProperties); + + string getType() const; +}; + +}} +#endif // INCLUDED_WW8_STTBF diff --git a/writerfilter/source/doctok/WW8StyleSheet.cxx b/writerfilter/source/doctok/WW8StyleSheet.cxx new file mode 100644 index 000000000000..3bf08eee430c --- /dev/null +++ b/writerfilter/source/doctok/WW8StyleSheet.cxx @@ -0,0 +1,206 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> + +namespace writerfilter { +namespace doctok { + +void WW8StyleSheet::initPayload() +{ + sal_uInt32 nCount = getEntryCount(); + + sal_uInt32 nOffset = get_size() + 2; + for (sal_uInt32 n = 0; n < nCount; ++n) + { + entryOffsets.push_back(nOffset); + + sal_uInt32 cbStd = getU16(nOffset); + nOffset += cbStd + 2; + } + + entryOffsets.push_back(nOffset); +} + +sal_uInt32 WW8StyleSheet::calcSize() +{ + return getCount(); +} + +sal_uInt32 WW8StyleSheet::getEntryCount() +{ + return get_cstd(); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8StyleSheet::getEntry(sal_uInt32 nIndex) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + sal_uInt32 nCount = entryOffsets[nIndex + 1] - entryOffsets[nIndex]; + + if (nCount > get_cbSTDBaseInFile() + 2U) + { + WW8Style * pStyle = new WW8Style(this, entryOffsets[nIndex], nCount); + + pStyle->setIndex(nIndex); + + pResult = writerfilter::Reference<Properties>::Pointer_t(pStyle); + } + + return pResult; +} + +rtl::OUString WW8Style::get_xstzName() +{ + sal_uInt32 nCount = getU8(0xc); + + if (nCount > 0) + { + Sequence aSeq(mSequence, 0xe, nCount * 2); + + rtl_uString * pNew = 0; + rtl_uString_newFromStr + (&pNew, reinterpret_cast<const sal_Unicode *>(&aSeq[0])); + + return rtl::OUString(pNew); + + } + + return get_xstzName1(); +} + +rtl::OUString WW8Style::get_xstzName1() +{ + WW8StyleSheet * pParentStyleSheet = dynamic_cast<WW8StyleSheet *>(mpParent); + + if (mpParent != NULL) + { + sal_uInt32 nOffset = pParentStyleSheet->get_cbSTDBaseInFile() + 2; + + if (nOffset < getCount()) + { + sal_uInt32 nCount = getU16(nOffset); + + if (nCount > 0) + { + Sequence aSeq(mSequence, nOffset + 2, nCount * 2); + + rtl_uString * pNew = 0; + rtl_uString_newFromStr + (&pNew, reinterpret_cast<const sal_Unicode *>(&aSeq[0])); + + return rtl::OUString(pNew); + + } + } + } + + return rtl::OUString(); +} + +sal_uInt32 WW8Style::get_upxstart() +{ + sal_uInt32 nResult = 0; + sal_uInt32 nCount = getU8(0xc); + + if (nCount > 0) + { + nResult = 0xc + 1 + nCount * 2; + + nResult += nResult % 2; + } + else + { + WW8StyleSheet * pParentStyleSheet = + dynamic_cast<WW8StyleSheet *>(mpParent); + + nResult = pParentStyleSheet->get_cbSTDBaseInFile() + 2; + + if (nResult < getCount()) + { + sal_uInt32 nCountTmp = getU16(nResult); + + nResult += 4 + nCountTmp * 2; + } + } + + return nResult; +} + +sal_uInt32 WW8Style::get_upx_count() +{ + return get_cupx(); +} + +writerfilter::Reference<Properties>::Pointer_t WW8Style::get_upx +(sal_uInt32 nIndex) +{ + writerfilter::Reference<Properties>::Pointer_t pResult; + + WW8StructBaseTmpOffset aOffset(this); + + aOffset.set(get_upxstart()); + + if (aOffset.get() > 0 ) + { + sal_uInt32 nCount; + + for (sal_uInt32 n = 0; n < nIndex; ++n) + { + nCount = getU16(aOffset); + + aOffset.inc(nCount + 2); + aOffset.inc(aOffset.get() % 2); + } + + nCount = getU16(aOffset); + + if (nCount > 0) + { + aOffset.inc(2); + + bool bIsPap = get_cupx() == 2 && nIndex == 0; + WW8PropertySet::Pointer_t + pProps(new WW8PropertySetImpl(*this, aOffset.get(), nCount, + bIsPap)); + + WW8PropertiesReference * pRef = + new WW8PropertiesReference(pProps); + + pResult = writerfilter::Reference<Properties>::Pointer_t(pRef); + } + } + + return pResult; +} + +void WW8Style::resolveNoAuto(Properties & /*rHandler*/) +{ +} + +}} diff --git a/writerfilter/source/doctok/WW8Table.cxx b/writerfilter/source/doctok/WW8Table.cxx new file mode 100644 index 000000000000..34765de5accb --- /dev/null +++ b/writerfilter/source/doctok/WW8Table.cxx @@ -0,0 +1,204 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> + +namespace writerfilter { +namespace doctok { + +/* WW8sprmTDefTable */ + +sal_uInt32 WW8sprmTDefTable::get_cellx_count() +{ + return getU8(0x4) + 1; +} + +sal_uInt16 WW8sprmTDefTable::get_cellx(sal_uInt32 nIndex) +{ + return getU16(0x5 + nIndex * 2); +} + +sal_uInt32 WW8sprmTDefTable::get_tc_count() +{ + return get_cellx_count() - 1; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8sprmTDefTable::get_tc(sal_uInt32 pos) +{ + return writerfilter::Reference<Properties>::Pointer_t + (new WW8TC(this, + 0x5 + get_cellx_count() * 2 + pos * WW8TC::getSize())); +} + +/* WW8sprmTTableBorders */ + +sal_uInt32 WW8sprmTTableBorders::get_rgbbrc_count() +{ + return 6; +} + +writerfilter::Reference<Properties>::Pointer_t +WW8sprmTTableBorders::get_rgbbrc(sal_uInt32 pos) +{ + return writerfilter::Reference<Properties>::Pointer_t + (new WW8BRC(*this, 0x3 + pos * WW8BRC::getSize())); +} + +/* WW8sprmTCellBottomColor */ + +sal_uInt32 WW8sprmTCellBottomColor::calcSize() +{ + return get_cellBottomColor_count() * 4 + 3; +} + +sal_uInt32 WW8sprmTCellBottomColor::get_cellBottomColor_count() +{ + return getU8(0x2) / 4; +} + +sal_uInt32 WW8sprmTCellBottomColor::get_cellBottomColor(sal_uInt32 pos) +{ + return getU32(0x3 + 4 * pos); +} + +/* WW8sprmTCellLeftColor */ + +sal_uInt32 WW8sprmTCellLeftColor::calcSize() +{ + return get_cellLeftColor_count() * 4 + 3; +} + +sal_uInt32 WW8sprmTCellLeftColor::get_cellLeftColor_count() +{ + return getU8(0x2) / 4; +} + +sal_uInt32 WW8sprmTCellLeftColor::get_cellLeftColor(sal_uInt32 pos) +{ + return getU32(0x3 + 4 * pos); +} + +/* WW8sprmTCellTopColor */ + +sal_uInt32 WW8sprmTCellTopColor::calcSize() +{ + return get_cellTopColor_count() * 4 + 3; +} + +sal_uInt32 WW8sprmTCellTopColor::get_cellTopColor_count() +{ + return getU8(0x2) / 4; +} + +sal_uInt32 WW8sprmTCellTopColor::get_cellTopColor(sal_uInt32 pos) +{ + return getU32(0x3 + 4 * pos); +} + +/* WW8sprmTCellRightColor */ + +sal_uInt32 WW8sprmTCellRightColor::calcSize() +{ + return get_cellRightColor_count() * 4 + 3; +} + +sal_uInt32 WW8sprmTCellRightColor::get_cellRightColor_count() +{ + return getU8(0x2) / 4; +} + +sal_uInt32 WW8sprmTCellRightColor::get_cellRightColor(sal_uInt32 pos) +{ + return getU32(0x3 + 4 * pos); +} + +/* WW8sprmTGridLineProps */ + +sal_uInt32 WW8sprmTGridLineProps::calcSize() +{ + return getSize(); +} + +/* WW8sprmTDefTableShd */ + +sal_uInt32 WW8sprmTDefTableShd::calcSize() +{ + return get_shd_count() * WW8SHD::getSize() + 3; +} + +sal_uInt32 WW8sprmTDefTableShd::get_shd_count() +{ + return getU8(0x2) / WW8SHD::getSize(); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8sprmTDefTableShd::get_shd(sal_uInt32 pos) +{ + return writerfilter::Reference<Properties>::Pointer_t + (new WW8SHD(*this, 0x3 + pos * WW8SHD::getSize())); +} + +/* WW8sprmTCellShd */ + +sal_uInt32 WW8sprmTCellShd::calcSize() +{ + return get_shd_count() * WW8CellShd::getSize(); +} + +sal_uInt32 WW8sprmTCellShd::get_shd_count() +{ + return getU8(0x2) / WW8CellShd::getSize(); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8sprmTCellShd::get_shd(sal_uInt32 pos) +{ + return writerfilter::Reference<Properties>::Pointer_t + (new WW8CellShd(*this, 0x3 + pos * WW8CellShd::getSize())); +} + +/* WW8sprmTCellShadow */ + +sal_uInt32 WW8sprmTCellShadow::calcSize() +{ + return get_cellShadow_count() * WW8CellShd::getSize(); +} + +sal_uInt32 WW8sprmTCellShadow::get_cellShadow_count() +{ + return getU8(0x2) / WW8CellShd::getSize(); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8sprmTCellShadow::get_cellShadow(sal_uInt32 pos) +{ + return writerfilter::Reference<Properties>::Pointer_t + (new WW8CellShd(*this, 0x3 + pos * WW8CellShd::getSize())); +} + +}} diff --git a/writerfilter/source/doctok/WW8Text.cxx b/writerfilter/source/doctok/WW8Text.cxx new file mode 100644 index 000000000000..746cf4547288 --- /dev/null +++ b/writerfilter/source/doctok/WW8Text.cxx @@ -0,0 +1,76 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <resources.hxx> + +namespace writerfilter { +namespace doctok { +sal_uInt32 WW8sprmPChgTabsPapx::calcSize() +{ + return getS8(0x2) + 3; +} + +sal_uInt32 WW8sprmPChgTabsPapx::get_dxaDel_count() +{ + return getS8(0x3); +} + +sal_Int16 WW8sprmPChgTabsPapx::get_dxaDel(sal_uInt32 pos) +{ + return getS16(0x4 + pos * 2); +} + +sal_uInt32 WW8sprmPChgTabsPapx::get_dxaAdd_count() +{ + return getS8(0x4 + get_dxaDel_count() * 2); +} + +sal_Int16 WW8sprmPChgTabsPapx::get_dxaAdd(sal_uInt32 pos) +{ + return getS16(0x4 + get_dxaDel_count() * 2 + 1 + pos * 2); +} + +sal_uInt32 WW8sprmPChgTabsPapx::get_tbdAdd_count() +{ + return get_dxaAdd_count(); +} + +writerfilter::Reference<Properties>::Pointer_t +WW8sprmPChgTabsPapx::get_tbdAdd(sal_uInt32 pos) +{ + //wntmsci compiler cannot handle 'too many inlines' ;-) + writerfilter::Reference<Properties>::Pointer_t pRet( new WW8TBD(this, + 0x4 + get_dxaDel_count() * 2 + 1 + get_dxaAdd_count() * 2 + + pos, 1)); + return pRet; + +/* return writerfilter::Reference<Properties>::Pointer_t + (new WW8TBD(this, + 0x4 + get_dxaDel_count() * 2 + 1 + get_dxaAdd_count() * 2 + + pos, 1));*/ +} +}} diff --git a/writerfilter/source/doctok/WW8inc.xsl b/writerfilter/source/doctok/WW8inc.xsl new file mode 100644 index 000000000000..956e2cad24be --- /dev/null +++ b/writerfilter/source/doctok/WW8inc.xsl @@ -0,0 +1,106 @@ +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xhtml="http://www.w3.org/1999/xhtml"> +<xsl:output method="text" encoding="iso-8859-1"/> + +<xsl:template match="/"> +<xsl:apply-templates select="//xhtml:body/xhtml:table"/> +</xsl:template> + +<xsl:template match="xhtml:table"> +<xsl:apply-templates select="xhtml:tbody/xhtml:tr[2]"/> +</xsl:template> + +<xsl:template name="handleTR"> +<xsl:param name="offset"/> +<xsl:param name="shift"/> +<xsl:variable name="name"><xsl:value-of select="xhtml:td[3]"/></xsl:variable> +<xsl:variable name="type"><xsl:value-of select="xhtml:td[4]"/></xsl:variable> +<xsl:variable name="saltype"> +<xsl:choose> + <xsl:when test="$type='U8'">sal_uInt8</xsl:when> + <xsl:when test="$type='S8'">sal_Int8</xsl:when> + <xsl:when test="$type='U16'">sal_uInt16</xsl:when> + <xsl:when test="$type='S16'">sal_Int16</xsl:when> + <xsl:when test="$type='U32'">sal_uInt32</xsl:when> + <xsl:when test="$type='S32'">sal_Int32</xsl:when> + <xsl:otherwise>void *</xsl:otherwise> +</xsl:choose> +</xsl:variable> +<xsl:variable name="bits"><xsl:value-of select="xhtml:td[5]"/></xsl:variable> +<xsl:variable name="mask"><xsl:value-of select="xhtml:td[6]"/></xsl:variable> +<xsl:variable name="comment"><xsl:value-of select="xhtml:td[7]"/></xsl:variable> +/** +<xsl:value-of select="$comment"/> + +offset : <xsl:value-of select="$offset"/> +name : <xsl:value-of select="$name"/> +type : <xsl:value-of select="$type"/> +shift : <xsl:value-of select="concat($shift, '
')"/> +*/ + +<xsl:value-of select="$saltype"/> get_<xsl:value-of select="$name"/>() const<xsl:choose> +<xsl:when test="$saltype='void *'">; +</xsl:when> +<xsl:otherwise> { return (get<xsl:value-of select="$type"/>(0x<xsl:value-of select="$offset"/>)<xsl:if test="string-length($mask)>0"> & 0x<xsl:value-of select="translate($mask, 'ABCDEF', 'abcdef')"/></xsl:if>)<xsl:if test="$shift>0"> >> <xsl:value-of select="$shift"/></xsl:if>; } +</xsl:otherwise> +</xsl:choose> +</xsl:template> + +<xsl:template match="xhtml:tr[./xhtml:td[position()=1]/text()]"> +<xsl:variable name="offset"><xsl:value-of select="xhtml:td[2]"/></xsl:variable> +<xsl:call-template name="handleTR"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift">0</xsl:with-param> +</xsl:call-template> +<xsl:variable name="shift1"><xsl:value-of select="substring-after(xhtml:td[5], ':')"/></xsl:variable> +<xsl:apply-templates select="following-sibling::xhtml:tr[position()=1]"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift" select="$shift1"/> +</xsl:apply-templates> +</xsl:template> + +<xsl:template match="xhtml:tr[not(./xhtml:td[position()=1]/text())]"> +<xsl:param name="offset"/> +<xsl:param name="shift"/> +<xsl:call-template name="handleTR"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift" select="$shift"/> +</xsl:call-template> +<xsl:variable name="shift1"><xsl:value-of select="$shift+substring-after(xhtml:td[5], ':')"/></xsl:variable> +<xsl:apply-templates select="following-sibling::xhtml:tr[position()=1]"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift" select="$shift1"/> +</xsl:apply-templates> +</xsl:template> + +<xsl:template match="*"> +<xsl:copy-of select="."/> +</xsl:template> + +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/WW8sprms.xsl b/writerfilter/source/doctok/WW8sprms.xsl new file mode 100644 index 000000000000..80afb9c853ee --- /dev/null +++ b/writerfilter/source/doctok/WW8sprms.xsl @@ -0,0 +1,66 @@ +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default" xmlns:xhtml="http://www.w3.org/1999/xhtml"> +<xsl:output method="xml" indent="yes"/> + +<xsl:template match="/"> +<out> +<xsl:apply-templates select=".//xhtml:tr[position() > 2]"/> +</out> +</xsl:template> + +<xsl:template match='xhtml:tr'> +<xsl:variable name='sprmname'><xsl:value-of select='xhtml:td[1]'/></xsl:variable> +<xsl:variable name='sprmid'><xsl:value-of select='xhtml:td[2]'/></xsl:variable> +<UML:Class> +<xsl:attribute name='xmi.id'><xsl:value-of select='$sprmname'/></xsl:attribute> +<xsl:attribute name='name'><xsl:value-of select='$sprmname'/></xsl:attribute> +<UML:ModelElement.stereotype> +<UML:Stereotype xmi.idref="ww8sprm"/> +</UML:ModelElement.stereotype> +<UML:ModelElement.taggedValue> +<UML:TaggedValue> +<UML:TaggedValue.dataValue><xsl:value-of select='$sprmid'/></UML:TaggedValue.dataValue> +<UML:TaggedValue.type> +<UML:TagDefinition xmi.idref="sprmcode"/> +</UML:TaggedValue.type> +</UML:TaggedValue> +</UML:ModelElement.taggedValue> +<UML:ModelElement.taggedValue> +<UML:TaggedValue> +<UML:TaggedValue.dataValue>rtf:<xsl:value-of select='$sprmname'/></UML:TaggedValue.dataValue> +<UML:TaggedValue.type> +<UML:TagDefinition xmi.idref="sprmid"/> +</UML:TaggedValue.type> +</UML:TaggedValue> +</UML:ModelElement.taggedValue> +</UML:Class> +</xsl:template> + +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/WW8xmi.xsl b/writerfilter/source/doctok/WW8xmi.xsl new file mode 100644 index 000000000000..d76921c2bdb7 --- /dev/null +++ b/writerfilter/source/doctok/WW8xmi.xsl @@ -0,0 +1,184 @@ +<!-- +************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default" xmlns:xhtml="http://www.w3.org/1999/xhtml"> +<xsl:output method="xml" indent="yes"/> + +<xsl:template match="/"> +<UML:Class xmi.id="dummy" name="dummy"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref='access'/> + </UML:ModelElement.stereotype> +<xsl:apply-templates select="//xhtml:body/xhtml:table"/> +</UML:Class> +</xsl:template> + +<xsl:template match="xhtml:table"> +<xsl:apply-templates select="xhtml:tbody/xhtml:tr[2]"/> +</xsl:template> + +<xsl:template name="handleTR"> +<xsl:param name="offset"/> +<xsl:param name="shift"/> +<xsl:variable name="name"><xsl:value-of select="xhtml:td[3]"/></xsl:variable> +<xsl:variable name="type"> +<xsl:choose> +<xsl:when test='contains(xhtml:td[4], "[")'> +<xsl:value-of select='substring-before(xhtml:td[4], "[")'/> +</xsl:when> +<xsl:otherwise> +<xsl:value-of select="xhtml:td[4]"/> +<xsl:variable name="stereotype">attribute</xsl:variable> +</xsl:otherwise> +</xsl:choose> +</xsl:variable> +<xsl:variable name='stereotype'> +<xsl:choose> +<xsl:when test='contains(xhtml:td[4], "[")'>array</xsl:when> +<xsl:otherwise>attribute</xsl:otherwise> +</xsl:choose> +</xsl:variable> +<xsl:variable name="saltype"> +<xsl:choose> + <xsl:when test="$type='U8'">sal_uInt8</xsl:when> + <xsl:when test="$type='S8'">sal_Int8</xsl:when> + <xsl:when test="$type='U16'">sal_uInt16</xsl:when> + <xsl:when test="$type='S16'">sal_Int16</xsl:when> + <xsl:when test="$type='U32'">sal_uInt32</xsl:when> + <xsl:when test="$type='S32'">sal_Int32</xsl:when> + <xsl:otherwise>void *</xsl:otherwise> +</xsl:choose> +</xsl:variable> +<xsl:variable name="bits"><xsl:value-of select="xhtml:td[5]"/></xsl:variable> +<xsl:variable name="mask"><xsl:value-of select="xhtml:td[6]"/></xsl:variable> +<xsl:variable name="comment"><xsl:value-of select="xhtml:td[7]"/></xsl:variable> + <UML:Classifier.feature> + <UML:Attribute><xsl:attribute name="name"><xsl:value-of select="$name"/></xsl:attribute> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="$comment"/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'comment'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="$offset"/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'offset'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="$shift"/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'shift'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="$mask"/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'mask'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="$bits"/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'bits'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:<xsl:value-of select='translate($name, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ")'/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'attrid'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> +<xsl:if test='$stereotype = "array"'> +<xsl:variable name='arraycount'><xsl:value-of select='substring-before(substring-after(xhtml:td[4], "["), "]")'/></xsl:variable> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="$arraycount"/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref = 'arraycount'/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> +</xsl:if> + <UML:StructuralFeature.type> + <UML:DataType><xsl:attribute name="xmi.idref"><xsl:value-of select="$type"/></xsl:attribute></UML:DataType> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype><xsl:attribute name="xmi.idref"><xsl:value-of select="$stereotype"/></xsl:attribute></UML:Stereotype> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> +</xsl:template> + +<xsl:template match="xhtml:tr[./xhtml:td[position()=1]/text()]"> +<xsl:variable name="offset"><xsl:value-of select="xhtml:td[2]"/></xsl:variable> +<xsl:call-template name="handleTR"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift">0</xsl:with-param> +</xsl:call-template> +<xsl:variable name="shift1"><xsl:value-of select="substring-after(xhtml:td[5], ':')"/></xsl:variable> +<xsl:apply-templates select="following-sibling::xhtml:tr[position()=1]"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift" select="$shift1"/> +</xsl:apply-templates> +</xsl:template> + +<xsl:template match="xhtml:tr[not(./xhtml:td[position()=1]/text())]"> +<xsl:param name="offset"/> +<xsl:param name="shift"/> +<xsl:call-template name="handleTR"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift" select="$shift"/> +</xsl:call-template> +<xsl:variable name="shift1"><xsl:value-of select="$shift+substring-after(xhtml:td[5], ':')"/></xsl:variable> +<xsl:apply-templates select="following-sibling::xhtml:tr[position()=1]"> +<xsl:with-param name="offset" select="$offset"/> +<xsl:with-param name="shift" select="$shift1"/> +</xsl:apply-templates> +</xsl:template> + +<xsl:template match="*"> +<xsl:copy-of select="."/> +</xsl:template> + +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/XNoteHelper.hxx b/writerfilter/source/doctok/XNoteHelper.hxx new file mode 100644 index 000000000000..faa7f3bb038d --- /dev/null +++ b/writerfilter/source/doctok/XNoteHelper.hxx @@ -0,0 +1,143 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_X_NOTE_HELPER_HXX +#define INCLUDED_X_NOTE_HELPER_HXX + +#ifndef INLCUED_PLCF_HXX +#include <PLCF.hxx> +#endif +#include <WW8DocumentImpl.hxx> + +namespace writerfilter { +namespace doctok +{ +/** + A helper class for footnotes and endnotes and annotations(aka X-notes). + */ +template <class T> +class XNoteHelper +{ + /// Character positions of X-notes in footnote document + WW8StructBase::Pointer_t mpCps; + + /// Character positions of references to X-notes + typename PLCF<T>::Pointer_t mpRefs; + + /// piece table for CP to FC conversion + WW8PieceTable::Pointer_t mpPieceTable; + + /// the document + WW8DocumentImpl * mpDocument; + + /// type of X-notes handled by this helper (PROP_FOOTNOTE, PROP_ENDNOTE) + PropertyType meType; + + /// offset in document where X-note subdocument starts + CpAndFc mCpAndFcOffset; + + /** + Return CpAndFc in document for X-note. + + @param nPos index of X-note + */ + CpAndFc getCpAndFc(sal_uInt32 nPos); + + /** + Return CpAndFc in document for reference to a certain X-note. + + @param nPos index of the X-note + */ + CpAndFc getRefCpAndFc(sal_uInt32 nPos); + +public: + typedef boost::shared_ptr<XNoteHelper> Pointer_t; + + XNoteHelper(WW8StructBase::Pointer_t pCps, + typename PLCF<T>::Pointer_t pRefs, + WW8PieceTable::Pointer_t pPieceTable, + WW8DocumentImpl * pDocument, + PropertyType eType, + CpAndFc cpAndFcOffset) + : mpCps(pCps), mpRefs(pRefs), mpPieceTable(pPieceTable), + mpDocument(pDocument), meType(eType), mCpAndFcOffset(cpAndFcOffset) + { + } + + /** + Initialize. + + Generates CpAndFcs in document for X-notes. + */ + void init(); + + /** + Return number of X-notes. + */ + sal_uInt32 getCount() const; + + /** + Return index of CpAndFc. + + @param rCpAndFc the CpAndFc to search + + @return the index of the rCpAndFc found or getCount() otherwise + */ + sal_uInt32 getIndexOfCpAndFc(const CpAndFc & rCpAndFc); + + /** + Return subdocument containing X-note. + + @param nIndex index of X-note. + */ + writerfilter::Reference<Stream>::Pointer_t get(sal_uInt32 nIndex); + + /** + Return subdocument containing X-note. + + @param rCpAndFc CpAndFc of the X-note's reference + */ + writerfilter::Reference<Stream>::Pointer_t get(const CpAndFc & rCpAndFc); + + /** + Return reference data structure of X-note. + + @param nIndex index of X-note + */ + T * getRef(sal_uInt32 nIndex); + + /** + Return reference data structure of X-note. + + @param rCpAndFc CpAndFc for the X-note's reference + */ + T * getRef(const CpAndFc & rCpAndFc); +}; + +}} + +#endif // INCLUDED_X_NOTE_HELPER_HXX diff --git a/writerfilter/source/doctok/XNoteHelperImpl.hxx b/writerfilter/source/doctok/XNoteHelperImpl.hxx new file mode 100644 index 000000000000..4cd70b984f24 --- /dev/null +++ b/writerfilter/source/doctok/XNoteHelperImpl.hxx @@ -0,0 +1,168 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_X_NOTE_HELPER_IMPL_HXX +#define INCLUDED_X_NOTE_HELPER_IMPL_HXX + +namespace writerfilter { +namespace doctok +{ +template <class T> +sal_uInt32 XNoteHelper<T>::getCount() const +{ + sal_uInt32 nResult = 0; + + if (mpCps.get() != NULL && mpCps->getCount() > 8) + nResult = ( mpCps->getCount() / 4) - 2; + + return nResult; +} + +template <class T> +CpAndFc XNoteHelper<T>::getCpAndFc(sal_uInt32 nPos) +{ + // There are getCount() + 1 entries in mpOffsets => greater + if (nPos > getCount()) + throw ExceptionNotFound("getCpAndFc"); + + Cp aCp(mCpAndFcOffset.getCp() + mpCps->getU32(nPos * 4)); + Fc aFc(mpPieceTable->cp2fc(aCp)); + CpAndFc aCpAndFc(aCp, aFc, meType); + + return aCpAndFc; +} + +template <class T> +CpAndFc XNoteHelper<T>::getRefCpAndFc(sal_uInt32 nPos) +{ + // There are getCount() entries in mpRefs => greater or equal + if (nPos >= getCount()) + throw ExceptionNotFound(""); + + Cp aCp(mpRefs->getFc(nPos)); + Fc aFc(mpPieceTable->cp2fc(aCp)); + CpAndFc aCpAndFc(aCp, aFc, meType); + + return aCpAndFc; +} + +template <class T> +writerfilter::Reference<Stream>::Pointer_t +XNoteHelper<T>::get(sal_uInt32 nPos) +{ + // There are getCount() entries => greater or equal + if (nPos >= getCount()) + throw ExceptionNotFound("get"); + + writerfilter::Reference<Stream>::Pointer_t pResult; + + CpAndFc aCpAndFcStart(getCpAndFc(nPos)); + CpAndFc aCpAndFcEnd(getCpAndFc(nPos + 1)); + + if (aCpAndFcStart < aCpAndFcEnd) + pResult = writerfilter::Reference<Stream>::Pointer_t + (new WW8DocumentImpl(*mpDocument, aCpAndFcStart, aCpAndFcEnd)); + + return pResult; +} + +template <class T> +sal_uInt32 XNoteHelper<T>::getIndexOfCpAndFc(const CpAndFc & rCpAndFc) +{ + sal_uInt32 nResult = getCount(); + + sal_uInt32 n = nResult; + while (n > 0) + { + --n; + + Cp aCp(mpRefs->getFc(n)); + Fc aFc(mpPieceTable->cp2fc(aCp)); + CpAndFc aCpAndFc(aCp, aFc, meType); + + if (aCpAndFc <= rCpAndFc) + { + nResult = n; + break; + } + } + + return nResult; +} + +template <class T> +writerfilter::Reference<Stream>::Pointer_t +XNoteHelper<T>::get(const CpAndFc & rCpAndFc) +{ + writerfilter::Reference<Stream>::Pointer_t pResult; + + sal_uInt32 n = getIndexOfCpAndFc(rCpAndFc); + + if (n < getCount()) + pResult = get(n); + + return pResult; +} + +template <class T> +T * +XNoteHelper<T>::getRef(sal_uInt32 nIndex) +{ + return mpRefs->getEntryPointer(nIndex); +} + +template <class T> +T * +XNoteHelper<T>::getRef(const CpAndFc & rCpAndFc) +{ + T * pResult = NULL; + + sal_uInt32 n = getIndexOfCpAndFc(rCpAndFc); + + if (n < getCount()) + { + pResult = getRef(n); + } + + return pResult; +} + +template <class T> +void XNoteHelper<T>::init() +{ + for (sal_uInt32 n = 0; n < getCount(); ++n) + { + CpAndFc aCpAndFc(getCpAndFc(n)); + mpDocument->insertCpAndFc(aCpAndFc); + + CpAndFc aCpAndFcRef(getRefCpAndFc(n)); + mpDocument->insertCpAndFc(aCpAndFcRef); + } +} +}} + +#endif // INCLUDED_X_NOTE_HELPER_IMPL_HXX diff --git a/writerfilter/source/doctok/analyzer.xsl b/writerfilter/source/doctok/analyzer.xsl new file mode 100644 index 000000000000..ce645bdbe064 --- /dev/null +++ b/writerfilter/source/doctok/analyzer.xsl @@ -0,0 +1,39 @@ +<!-- +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output method="text" /> +<xsl:include href="resourcetools.xsl"/> + +<xsl:template match="/"> + <xsl:call-template name="analyzerdoctokids"/> +</xsl:template> + +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/cleanupresources b/writerfilter/source/doctok/cleanupresources new file mode 100755 index 000000000000..646c1ea4e0a7 --- /dev/null +++ b/writerfilter/source/doctok/cleanupresources @@ -0,0 +1,5 @@ +#!/bin/bash + +TEMP=`mktemp -t cleanupresources` +xsltproc tidyxmi.xsl resources.xmi | xmllint --format - > $TEMP +mv $TEMP resources.xmi diff --git a/writerfilter/source/doctok/compactxmi.xsl b/writerfilter/source/doctok/compactxmi.xsl new file mode 100644 index 000000000000..36ab4f5c5f9a --- /dev/null +++ b/writerfilter/source/doctok/compactxmi.xsl @@ -0,0 +1,262 @@ +<xsl:stylesheet + version="1.0" + xmlns:xsl="http://www.w3.org/1999/XSL/Transform" + xmlns:UML = 'org.omg.xmi.namespace.UML' + xmlns:exslt="http://exslt.org/common" + xml:space="default"> + <xsl:output method="xml"/> + + <xsl:template match="/"> + <xsl:apply-templates select="//UML:Model"/> + </xsl:template> + + <xsl:template match="UML:Model"> + <model> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:call-template name="nostereotype"/> + <xsl:call-template name="ww8resources"/> + <xsl:call-template name="sprms"/> + </model> + </xsl:template> + + <xsl:template name="nostereotype"> + <xsl:for-each select="UML:Namespace.ownedElement/UML:Class[not(UML:ModelElement.stereotype)]"> + <xsl:variable name="myid" select="@xmi.id"/> + <class> + <xsl:attribute name="name"> + <xsl:value-of select="$myid"/> + </xsl:attribute> + <xsl:attribute name="resource"> + <xsl:for-each select="//UML:Generalization[UML:Generalization.child/UML:Class/@xmi.idref=$myid]"> + <xsl:value-of select="UML:Generalization.parent/UML:Class/@xmi.idref"/> + </xsl:for-each> + </xsl:attribute> + <xsl:apply-templates select=".//UML:Attribute|.//UML:Operation" mode="ww8resource"/> + </class> + </xsl:for-each> + </xsl:template> + + <xsl:template name="ww8resources"> + <xsl:for-each select="UML:Namespace.ownedElement/UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8resource' and not(UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8sprm')]"> + <xsl:sort select="@xmi.id"/> + <xsl:call-template name="ww8resource"/> + </xsl:for-each> + </xsl:template> + + <xsl:template name="ww8resource"> + <xsl:variable name="myid" select="@xmi.id"/> + <xsl:variable name="classid"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">classid</xsl:with-param> + </xsl:call-template> + </xsl:variable> + <ww8resource> + <xsl:attribute name="name"> + <xsl:value-of select="$myid"/> + </xsl:attribute> + <xsl:attribute name="resource"> + <xsl:for-each select="//UML:Generalization[UML:Generalization.child/UML:Class/@xmi.idref=$myid]"> + <xsl:value-of select="UML:Generalization.parent/UML:Class/@xmi.idref"/> + </xsl:for-each> + </xsl:attribute> + <xsl:if test="string-length($classid) > 0"> + <xsl:attribute name="classid"> + <xsl:value-of select="$classid"/> + </xsl:attribute> + </xsl:if> + <xsl:for-each select="UML:ModelElement.stereotype/UML:Stereotype"> + <xsl:if test="@xmi.idref != 'ww8resource'"> + <stereotype> + <xsl:attribute name="name"> + <xsl:value-of select="@xmi.idref"/> + </xsl:attribute> + </stereotype> + </xsl:if> + </xsl:for-each> + <xsl:apply-templates select=".//UML:Attribute|.//UML:Operation" mode="ww8resource"/> + </ww8resource> + </xsl:template> + + <xsl:template name="gettaggedvalue"> + <xsl:param name="name"/> + <xsl:for-each select="UML:ModelElement.taggedValue/UML:TaggedValue[UML:TaggedValue.type/UML:TagDefinition/@xmi.idref=$name]"> + <xsl:value-of select="UML:TaggedValue.dataValue"/> + </xsl:for-each> + </xsl:template> + + <xsl:template name="sizefortype"> + <xsl:param name="type"/> + <xsl:choose> + <xsl:when test="$type='S8'">1</xsl:when> + <xsl:when test="$type='U8'">1</xsl:when> + <xsl:when test="$type='S16'">2</xsl:when> + <xsl:when test="$type='U16'">2</xsl:when> + <xsl:when test="$type='S32'">4</xsl:when> + <xsl:when test="$type='U32'">4</xsl:when> + <xsl:otherwise>0</xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template name="bits"> + <xsl:param name="bits"/> + <bits> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:attribute name="bits"> + <xsl:value-of select="$bits"/> + </xsl:attribute> + <xsl:attribute name="token"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">attrid</xsl:with-param> + </xsl:call-template> + </xsl:attribute> + </bits> + </xsl:template> + + <xsl:template match="UML:Attribute" mode="ww8resource"> + <xsl:variable name="mask"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">mask</xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="offset"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">offset</xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="type"> + <xsl:value-of select="UML:StructuralFeature.type/UML:DataType/@xmi.idref"/> + </xsl:variable> + <xsl:variable name="size"> + <xsl:call-template name="sizefortype"> + <xsl:with-param name="type" select="$type"/> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="arraycount"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">arraycount</xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:choose> + <xsl:when test="string-length($mask) = 0"> + <attribute> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:attribute name="type"> + <xsl:value-of select="$type"/> + </xsl:attribute> + <xsl:attribute name="size"> + <xsl:value-of select="$size"/> + </xsl:attribute> + <xsl:for-each select="UML:ModelElement.stereotype/UML:Stereotype[@xmi.idref='array']"> + <xsl:attribute name="array-count"> + <xsl:value-of select="$arraycount"/> + </xsl:attribute> + </xsl:for-each> + <xsl:attribute name="token"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">attrid</xsl:with-param> + </xsl:call-template> + </xsl:attribute> + </attribute> + </xsl:when> + <xsl:otherwise> + <xsl:variable name="attrswithoffset"> + <xsl:for-each select="ancestor::UML:Class//UML:Attribute[UML:ModelElement.taggedValue/UML:TaggedValue[UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='offset' and UML:TaggedValue.dataValue=$offset]]"> + <xsl:sort select="UML:ModelElement.taggedValue/UML:TaggedValue[UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='shift']/UML:TaggedValue.dataValue" data-type="number" order="descending"/> + <xsl:copy-of select="."/> + </xsl:for-each> + </xsl:variable> + <xsl:text>
</xsl:text> + <xsl:if test="@name = exslt:node-set($attrswithoffset)/UML:Attribute[1]/@name"> + <bitfield> + <xsl:attribute name="size"> + <xsl:value-of select="$size"/> + </xsl:attribute> + <xsl:attribute name="type"> + <xsl:value-of select="$type"/> + </xsl:attribute> + <xsl:variable name="allbits" select="8 * $size"/> + <xsl:for-each select="exslt:node-set($attrswithoffset)/UML:Attribute"> + <xsl:variable name="lastshift"> + <xsl:choose> + <xsl:when test="count(preceding-sibling::UML:Attribute) = 0"> + <xsl:value-of select="$allbits"/> + </xsl:when> + <xsl:otherwise> + <xsl:value-of select="preceding-sibling::UML:Attribute[1]/UML:ModelElement.taggedValue/UML:TaggedValue[UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='shift']/UML:TaggedValue.dataValue"/> + </xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="bits" select="$lastshift - UML:ModelElement.taggedValue/UML:TaggedValue[UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='shift']/UML:TaggedValue.dataValue"/> + <xsl:call-template name="bits"> + <xsl:with-param name="bits" select="$bits"/> + </xsl:call-template> + </xsl:for-each> + </bitfield> + </xsl:if> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template match="UML:Operation" mode="ww8resource"> + <operation> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:attribute name="type"> + <xsl:for-each select="UML:BehavioralFeature.parameter/UML:Parameter[@kind='return']"> + <xsl:value-of select="UML:Parameter.type/UML:Class/@xmi.idref"/> + </xsl:for-each> + </xsl:attribute> + <xsl:attribute name="token"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">opid</xsl:with-param> + </xsl:call-template> + </xsl:attribute> + <xsl:for-each select="UML:ModelElement.stereotype"> + <stereotype> + <xsl:value-of select="UML:Stereotype/@xmi.idref"/> + </stereotype> + </xsl:for-each> + </operation> + </xsl:template> + + <xsl:template match="*" mode="ww8resources"> + <xsl:apply-templates select="*" mode="ww8resources"/> + </xsl:template> + + <xsl:template name="sprms"> + <xsl:for-each select="UML:Namespace.ownedElement/UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8sprm']"> + <xsl:sort select="@xmi.id"/> + <sprm> + <xsl:attribute name="name"> + <xsl:value-of select="@xmi.id"/> + </xsl:attribute> + <xsl:attribute name="code"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">sprmcode</xsl:with-param> + </xsl:call-template> + </xsl:attribute> + <xsl:attribute name="kind"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">kind</xsl:with-param> + </xsl:call-template> + </xsl:attribute> + <xsl:attribute name="token"> + <xsl:call-template name="gettaggedvalue"> + <xsl:with-param name="name">sprmid</xsl:with-param> + </xsl:call-template> + </xsl:attribute> + <xsl:if test="UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8resource'"> + <xsl:apply-templates select=".//UML:Attribute|.//UML:Operation" mode="ww8resource"/> + </xsl:if> + </sprm> + </xsl:for-each> + </xsl:template> + +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/doctokLoggers.hxx b/writerfilter/source/doctok/doctokLoggers.hxx new file mode 100644 index 000000000000..b7dc7e0aa48f --- /dev/null +++ b/writerfilter/source/doctok/doctokLoggers.hxx @@ -0,0 +1,42 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef INCLUDED_DOCTOK_LOGGERS_HXX +#define INCLUDED_DOCTOK_LOGGERS_HXX + +#ifdef DEBUG + +#include <resourcemodel/TagLogger.hxx> + +namespace writerfilter { + namespace doctok { + extern TagLogger::Pointer_t debug_logger; + } +} + +#endif // DEBUG +#endif // INCLUDED_DOCTOK_LOGGERS_HXX diff --git a/writerfilter/source/doctok/dopbase.xml b/writerfilter/source/doctok/dopbase.xml new file mode 100644 index 000000000000..8beb21d8cf08 --- /dev/null +++ b/writerfilter/source/doctok/dopbase.xml @@ -0,0 +1,91 @@ +<model> + <ww8resource name="DopBase" resource="Properties"> + <bitfield size="4" type="U32"> + <bits name="fFacingPages" bits="1" token="rtf:fFacingPages"/> + <bits name="unused1" bits="1" token="rtf:unused1"/> + <bits name="fPMHMainDoc" bits="1" token="rtf:fPMHMainDoc"/> + <bits name="unused2" bits="2" token="rtf:unused2"/> + <bits name="fpc" bits="2" token="rtf:fpc"/> + <bits name="unused3" bits="1" token="rtf:unused3"/> + <bits name="unused4" bits="8" token="rtf:unused4"/> + <bits name="rncFtn" bits="2" token="rtf:rncFtn"/> + <bits name="nFtn" bits="14" token="rtf:nFtn"/> + </bitfield> + <bitfield size="4" type="U32"> + <bits name="unused5" bits="1" token="rtf:unused5"/> + <bits name="unused6" bits="1" token="rtf:unused6"/> + <bits name="unused7" bits="1" token="rtf:unused7"/> + <bits name="unused8" bits="1" token="rtf:unused8"/> + <bits name="unused9" bits="1" token="rtf:unused9"/> + <bits name="unused10" bits="1" token="rtf:unused10"/> + <bits name="fSplAllDone" bits="1" token="rtf:fSplAllDone"/> + <bits name="fSplAllClean" bits="1" token="rtf:fSplAllClean"/> + <bits name="fSplHideErrors" bits="1" token="rtf:fSplHideErrors"/> + <bits name="fGramHideErrors" bits="1" token="rtf:fGramHideErrors"/> + <bits name="fLabelDoc" bits="1" token="rtf:fLabelDoc"/> + <bits name="fHyphCapitals" bits="1" token="rtf:fHyphCapitals"/> + <bits name="fAutoHyphen" bits="1" token="rtf:fAutoHyphen"/> + <bits name="fFormNoFields" bits="1" token="rtf:fFormNoFields"/> + <bits name="fLinkStyles" bits="1" token="rtf:fLinkStyles"/> + <bits name="fRevMarking" bits="1" token="rtf:fRevMarking"/> + <bits name="unused11" bits="1" token="rtf:unused11"/> + <bits name="fExactCWords" bits="1" token="rtf:fExactCWords"/> + <bits name="fPagHidden" bits="1" token="rtf:fPagHidden"/> + <bits name="fPagResults" bits="1" token="rtf:fPagResults"/> + <bits name="fLockAtn" bits="1" token="rtf:fLockAtn"/> + <bits name="fMirrorMargins" bits="1" token="rtf:fMirrorMargins"/> + <bits name="fWord97Compat" bits="1" token="rtf:fWord97Compat"/> + <bits name="unused12" bits="1" token="rtf:unused12"/> + <bits name="unused13" bits="1" token="rtf:unused13"/> + <bits name="fProtEnabled" bits="1" token="rtf:fProtEnabled"/> + <bits name="fDispFormFldSel" bits="1" token="rtf:fDispFormFldSel"/> + <bits name="fRMView" bits="1" token="rtf:fRMView"/> + <bits name="fRMPrint" bits="1" token="rtf:fRMPrint"/> + <bits name="fLockVbaProj" bits="1" token="rtf:fLockVbaProj"/> + <bits name="fLockRev" bits="1" token="rtf:fLockRev"/> + <bits name="fEmbedFonts" bits="1" token="rtf:fEmbedFonts"/> + </bitfield> + <attribute name="copts60" type="U16" size="2" token="rtf:copts60"/> + <attribute name="dxaTab" type="U16" size="2" token="rtf:dxaTab"/> + <attribute name="cpgWebOpt" type="U16" size="2" token="rtf:cpgWebOpt"/> + <attribute name="dxaHotZ" type="U16" size="2" token="rtf:dxaHotZ"/> + <attribute name="cConsecHypLim" type="U16" size="2" token="rtf:cConsecHypLim"/> + <attribute name="wSpare2" type="U16" size="2" token="rtf:wSpare2"/> + <attribute name="dttmCreated" type="U32" size="4" token="rtf:dttmCreated"/> + <attribute name="dttmRevised" type="U32" size="4" token="rtf:dttmRevised"/> + <attribute name="dttmLastPrint" type="U32" size="4" token="rtf:dttmLastPrint"/> + <attribute name="nRevision" type="U16" size="2" token="rtf:nRevision"/> + <attribute name="tmEdited" type="U32" size="4" token="rtf:tmEdited"/> + <attribute name="cWords" type="U32" size="4" token="rtf:cWords"/> + <attribute name="cCh" type="U32" size="4" token="rtf:cCh"/> + <attribute name="cPg" type="U16" size="2" token="rtf:cPg"/> + <attribute name="cParas" type="U32" size="4" token="rtf:cParas"/> + <bitfield size="4" type="U32"> + <bits name="rncEdn" bits="2" token="rtf:rncEdn"/> + <bits name="nEdn" bits="14" token="rtf:"/> + <bits name="epc" bits="2" token="rtf:"/> + <bits name="unused14" bits="4" token="rtf:unused14"/> + <bits name="unused15" bits="4" token="rtf:unused15"/> + <bits name="fPrintFormData" bits="1" token="rtf:fPrintFormData"/> + <bits name="fSaveFormData" bits="1" token="rtf:fSaveFormData"/> + <bits name="fShadeFormData" bits="1" token="rtf:fShadeFormData"/> + <bits name="fShadeMergeFields" bits="1" token="rtf:fShadeMergeFields"/> + <bits name="reserved2" bits="1" token="rtf:reserved2"/> + <bits name="fIncludeSubdocsInStats" bits="1" token="rtf:fIncludeSubdocsInStats"/> + </bitfield> + <attribute name="cLines" type="U32" size="4" token="rtf:cLines"/> + <attribute name="cWordsWithSubdocs" type="U32" size="4" token="rtf:cWordsWithSubdocs"/> + <attribute name="cChWithSubdocs" type="U32" size="4" token="rtf:cChWithSubdocs"/> + <attribute name="cPgWithSubdocs" type="U16" size="2" token="rtf:cPgWithSubdocs"/> + <attribute name="cParasWithSubdocs" type="U32" size="4" token="rtf:cParasWithSubdocs"/> + <attribute name="cLinesWithSubdocs" type="U32" size="4" token="rtf:cLinesWithSubdocs"/> + <attribute name="lKeyProtDoc" type="U32" size="4" token="rtf:lKeyProtDoc"/> + <bitfield size="2" type="U16"> + <bits name="wvkoSaved" bits="3" token="rtf:wvkoSaved"/> + <bits name="pctWwdSaved" bits="9" token="rtf:pctWwdSaved"/> + <bits name="zkSaved" bits="2" token="rtf:zkSaved"/> + <bits name="unused16" bits="1" token="rtf:unused16"/> + <bits name="iGutterPos" bits="1" token="rtf:iGutterPos"/> + </bitfield> + </ww8resource> +</model>
\ No newline at end of file diff --git a/writerfilter/source/doctok/escher.html b/writerfilter/source/doctok/escher.html new file mode 100644 index 000000000000..7d82c773d54f --- /dev/null +++ b/writerfilter/source/doctok/escher.html @@ -0,0 +1,207 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> +<html> + <head> + <title></title> + </head> + + <body> + <h1></h1> + +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">rotation</font><p></p></td><td valign="top"><font face=" , " size="2">4</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">fixed point: 16.16 degrees<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockRotation</font><p></p></td><td valign="top"><font face=" , " size="2">119</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">No rotation</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockAspectRatio</font><p></p></td><td valign="top"><font face=" , " size="2">120</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Don't allow changes in aspect ratio</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockPosition</font><p></p></td><td valign="top"><font face=" , " size="2">121</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Don't allow the shape to be moved</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockAgainstSelect</font><p></p></td><td valign="top"><font face=" , " size="2">122</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Shape may not be selected</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockCropping</font><p></p></td><td valign="top"><font face=" , " size="2">123</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">No cropping this shape</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockVertices</font><p></p></td><td valign="top"><font face=" , " size="2">124</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Edit Points not allowed</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockText</font><p></p></td><td valign="top"><font face=" , " size="2">125</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Do not edit text</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockAdjustHandles</font><p></p></td><td valign="top"><font face=" , " size="2">126</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Do not adjust</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockAgainstGrouping</font><p></p></td><td valign="top"><font face=" , " size="2">127</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Do not group this shape<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lTxid</font><p></p></td><td valign="top"><font face=" , " size="2">128</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">id for the text, value determined by the host</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxTextLeft</font><p></p></td><td valign="top"><font face=" , " size="2">129</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/10 inch</font><p></p></td><td valign="top"><font face=" , " size="2">margins relative to shape's inscribed text rectangle (in EMUs)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dyTextTop</font><p></p></td><td valign="top"><font face=" , " size="2">130</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/20 inch</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxTextRight</font><p></p></td><td valign="top"><font face=" , " size="2">131</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/10 inch</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dyTextBottom</font><p></p></td><td valign="top"><font face=" , " size="2">132</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/20 inch</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">WrapText</font><p></p></td><td valign="top"><font face=" , " size="2">133</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOWRAPMODE</b></font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Wrap text at shape margins</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">scaleText</font><p></p></td><td valign="top"><font face=" , " size="2">134</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Text zoom/scale (used if fFitTextToShape)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">anchorText</font><p></p></td><td valign="top"><font face=" , " size="2">135</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOANCHOR</b></font><p></p></td><td valign="top"><font face=" , " size="2">Top</font><p></p></td><td valign="top"><font face=" , " size="2">How to anchor the text</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">txflTextFlow</font><p></p></td><td valign="top"><font face=" , " size="2">136</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOTXFL</b></font><p></p></td><td valign="top"><font face=" , " size="2">HorzN</font><p></p></td><td valign="top"><font face=" , " size="2">Text flow</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">cdirFont</font><p></p></td><td valign="top"><font face=" , " size="2">137</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCDIR</b></font><p></p></td><td valign="top"><font face=" , " size="2">msocdir0</font><p></p></td><td valign="top"><font face=" , " size="2">Font rotation</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">hspNext</font><p></p></td><td valign="top"><font face=" , " size="2">138</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOHSP</b></font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">ID of the next shape (used by Word for linked textboxes)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">txdir</font><p></p></td><td valign="top"><font face=" , " size="2">139</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOTXDIR</b></font><p></p></td><td valign="top"><font face=" , " size="2">LTR</font><p></p></td><td valign="top"><font face=" , " size="2">Bi-Di Text direction</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fSelectText</font><p></p></td><td valign="top"><font face=" , " size="2">187</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE if single click selects text, FALSE if two clicks</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fAutoTextMargin</font><p></p></td><td valign="top"><font face=" , " size="2">188</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">use host's margin calculations</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fRotateText</font><p></p></td><td valign="top"><font face=" , " size="2">189</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Rotate text with shape</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fFitShapeToText</font><p></p></td><td valign="top"><font face=" , " size="2">190</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Size shape to fit text size</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fFitTextToShape</font><p></p></td><td valign="top"><font face=" , " size="2">191</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Size text to fit shape size<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextUNICODE</font><p></p></td><td valign="top"><font face=" , " size="2">192</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">UNICODE text string</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextRTF</font><p></p></td><td valign="top"><font face=" , " size="2">193</font><p></p></td><td valign="top"><font face=" , " size="2">char*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">RTF text string</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextAlign</font><p></p></td><td valign="top"><font face=" , " size="2">194</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOGEOTEXTALIGN</b></font><p></p></td><td valign="top"><font face=" , " size="2">Center</font><p></p></td><td valign="top"><font face=" , " size="2">alignment on curve</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextSize</font><p></p></td><td valign="top"><font face=" , " size="2">195</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">36<<16</font><p></p></td><td valign="top"><font face=" , " size="2">default point size</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextSpacing</font><p></p></td><td valign="top"><font face=" , " size="2">196</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2">fixed point 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFont</font><p></p></td><td valign="top"><font face=" , " size="2">197</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">font family name</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFReverseRows</font><p></p></td><td valign="top"><font face=" , " size="2">240</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Reverse row order</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fGtext</font><p></p></td><td valign="top"><font face=" , " size="2">241</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Has text effect</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFVertical</font><p></p></td><td valign="top"><font face=" , " size="2">242</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Rotate characters</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFKern</font><p></p></td><td valign="top"><font face=" , " size="2">243</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Kern characters</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFTight</font><p></p></td><td valign="top"><font face=" , " size="2">244</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Tightening or tracking</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFStretch</font><p></p></td><td valign="top"><font face=" , " size="2">245</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Stretch to fit shape</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFShrinkFit</font><p></p></td><td valign="top"><font face=" , " size="2">246</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Char bounding box</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFBestFit</font><p></p></td><td valign="top"><font face=" , " size="2">247</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Scale text-on-path</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFNormalize</font><p></p></td><td valign="top"><font face=" , " size="2">248</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Stretch char height</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFDxMeasure</font><p></p></td><td valign="top"><font face=" , " size="2">249</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Do not measure along path</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFBold</font><p></p></td><td valign="top"><font face=" , " size="2">250</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Bold font</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFItalic</font><p></p></td><td valign="top"><font face=" , " size="2">251</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Italic font</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFUnderline</font><p></p></td><td valign="top"><font face=" , " size="2">252</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Underline font</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFShadow</font><p></p></td><td valign="top"><font face=" , " size="2">253</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Shadow font</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFSmallcaps</font><p></p></td><td valign="top"><font face=" , " size="2">254</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Small caps font</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">gtextFStrikethrough</font><p></p></td><td valign="top"><font face=" , " size="2">255</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Strike through font<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="7"><colgroup><col valign="top" width="96"><col valign="top" width="45"><col valign="top" width="49"><col valign="top" width="49"><col valign="top" width="0"><col valign="top" width="192"><col valign="top" width="1"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Default</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">cropFromTop</font><p></p></td><td valign="top"><font face=" , " size="2">256</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">16.16 fraction times total image width or height, as appropriate.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">cropFromBottom</font><p></p></td><td valign="top"><font face=" , " size="2">257</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">cropFromLeft</font><p></p></td><td valign="top"><font face=" , " size="2">258</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">cropFromRight</font><p></p></td><td valign="top"><font face=" , " size="2">259</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pib</font><p></p></td><td valign="top"><font face=" , " size="2">260</font><p></p></td><td valign="top"><font face=" , " size="2">IMsoBlip*</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip to display</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pibName</font><p></p></td><td valign="top"><font face=" , " size="2">261</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip file name</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pibFlags</font><p></p></td><td valign="top"><font face=" , " size="2">262</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBLIPFLAGS</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Comment</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip flags</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureTransparent</font><p></p></td><td valign="top"><font face=" , " size="2">263</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">~0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">transparent color (none if ~0UL) </font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureContrast</font><p></p></td><td valign="top"><font face=" , " size="2">264</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">contrast setting</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureBrightness</font><p></p></td><td valign="top"><font face=" , " size="2">265</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">brightness setting</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureGamma</font><p></p></td><td valign="top"><font face=" , " size="2">266</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">16.16 gamma</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureId</font><p></p></td><td valign="top"><font face=" , " size="2">267</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Host-defined ID for OLE objects (usually a pointer)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureDblCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">268</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">This</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Modification used if shape has double shadow</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureFillCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">269</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">undefined</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureLineCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">270</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">undefined</font><p></p></td><td colspan="3" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pibPrint</font><p></p></td><td valign="top"><font face=" , " size="2">271</font><p></p></td><td valign="top"><font face=" , " size="2">IMsoBlip*</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip to display when printing</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pibPrintName</font><p></p></td><td valign="top"><font face=" , " size="2">272</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip file name</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pibPrintFlags</font><p></p></td><td valign="top"><font face=" , " size="2">273</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBLIPFLAGS</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Comment</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip flags</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fNoHitTestPicture</font><p></p></td><td valign="top"><font face=" , " size="2">316</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Do not hit test the picture</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureGray</font><p></p></td><td valign="top"><font face=" , " size="2">317</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">grayscale display</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureBiLevel</font><p></p></td><td valign="top"><font face=" , " size="2">318</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">bi-level display</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pictureActive</font><p></p></td><td valign="top"><font face=" , " size="2">319</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Server is active (OLE objects only)<p></p></font></td></tr></tbody></table> +<table border="1" cellpadding="1" cols="5">
+ <tbody><tr><td valign="top"><font face=" , " size="2">Property</font></td>
+ <td valign="top"><font face=" , " size="2">PID</font></td>
+ <td valign="top"><font face=" , " size="2">Type</font></td>
+ <td valign="top"><font face=" , " size="2">Default</font></td>
+ <td valign="top"><font face=" , " size="2">Description</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">geoLeft</font></td>
+ <td valign="top"><font face=" , " size="2">320</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2">Defines the G (geometry) coordinate
+ space.</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">geoTop</font></td>
+ <td valign="top"><font face=" , " size="2">321</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">geoRight</font></td>
+ <td valign="top"><font face=" , " size="2">322</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">21600</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">geoBottom</font></td>
+ <td valign="top"><font face=" , " size="2">323</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">21600</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">shapePath</font></td>
+ <td valign="top"><font face=" , " size="2">324</font></td>
+ <td valign="top"><font face=" , " size="2"><b>MSOSHAPEPATH</b></font></td>
+ <td valign="top"><font face=" , " size="2">msoshapeLinesClosed</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">pVertices</font></td>
+ <td valign="top"><font face=" , " size="2">325</font></td>
+ <td valign="top"><font face=" , " size="2"><b>IMsoArray</b></font></td>
+ <td valign="top"><font face=" , " size="2">NULL</font></td>
+ <td valign="top"><font face=" , " size="2">An array of points, in G units.</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">pSegmentInfo</font></td>
+ <td valign="top"><font face=" , " size="2">326</font></td>
+ <td valign="top"><font face=" , " size="2"><b>IMsoArray</b></font></td>
+ <td valign="top"><font face=" , " size="2">NULL</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjustValue</font></td>
+ <td valign="top"><font face=" , " size="2">327</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2">Adjustment values corresponding to the
+ positions of the adjust handles of the shape. The number
+ of values used and their allowable ranges vary from shape
+ type to shape type.</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust2Value</font></td>
+ <td valign="top"><font face=" , " size="2">328</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust3Value</font></td>
+ <td valign="top"><font face=" , " size="2">329</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust4Value</font></td>
+ <td valign="top"><font face=" , " size="2">330</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust5Value</font></td>
+ <td valign="top"><font face=" , " size="2">331</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust6Value</font></td>
+ <td valign="top"><font face=" , " size="2">332</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust7Value</font></td>
+ <td valign="top"><font face=" , " size="2">333</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust8Value</font></td>
+ <td valign="top"><font face=" , " size="2">334</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust9Value</font></td>
+ <td valign="top"><font face=" , " size="2">335</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">adjust10Value</font></td>
+ <td valign="top"><font face=" , " size="2">336</font></td>
+ <td valign="top"><font face=" , " size="2">LONG</font></td>
+ <td valign="top"><font face=" , " size="2">0</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">fShadowOK</font></td>
+ <td valign="top"><font face=" , " size="2">378</font></td>
+ <td valign="top"><font face=" , " size="2">BOOL</font></td>
+ <td valign="top"><font face=" , " size="2">TRUE</font></td>
+ <td valign="top"><font face=" , " size="2">Shadow may be set</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">f3DOK</font></td>
+ <td valign="top"><font face=" , " size="2">379</font></td>
+ <td valign="top"><font face=" , " size="2">BOOL</font></td>
+ <td valign="top"><font face=" , " size="2">TRUE</font></td>
+ <td valign="top"><font face=" , " size="2">3D may be set</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">fLineOK</font></td>
+ <td valign="top"><font face=" , " size="2">380</font></td>
+ <td valign="top"><font face=" , " size="2">BOOL</font></td>
+ <td valign="top"><font face=" , " size="2">TRUE</font></td>
+ <td valign="top"><font face=" , " size="2">Line style may be set</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">fGtextOK</font></td>
+ <td valign="top"><font face=" , " size="2">381</font></td>
+ <td valign="top"><font face=" , " size="2">BOOL</font></td>
+ <td valign="top"><font face=" , " size="2">FALSE</font></td>
+ <td valign="top"><font face=" , " size="2">Text effect (WordArt) supported</font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">fFillShadeShapeOK</font></td>
+ <td valign="top"><font face=" , " size="2">382</font></td>
+ <td valign="top"><font face=" , " size="2">BOOL</font></td>
+ <td valign="top"><font face=" , " size="2">FALSE</font></td>
+ <td valign="top"><font face=" , " size="2"> </font></td>
+ </tr>
+ <tr>
+ <td valign="top"><font face=" , " size="2">fFillOK</font></td>
+ <td valign="top"><font face=" , " size="2">383</font></td>
+ <td valign="top"><font face=" , " size="2">BOOL</font></td>
+ <td valign="top"><font face=" , " size="2">TRUE</font></td>
+ <td valign="top"><font face=" , " size="2">OK to fill the shape through the UI or
+ VBA?</font></td>
+ </tr>
+</tbody></table> +<table border="0" cellpadding="7" cols="6"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="0"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Default</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillType</font><p></p></td><td valign="top"><font face=" , " size="2">384</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOFILLTYPE</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Solid</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Type of fill</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillColor</font><p></p></td><td valign="top"><font face=" , " size="2">385</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">white</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Foreground color</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillOpacity</font><p></p></td><td valign="top"><font face=" , " size="2">386</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fixed 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillBackColor</font><p></p></td><td valign="top"><font face=" , " size="2">387</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">white</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Background color</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillBackOpacity</font><p></p></td><td valign="top"><font face=" , " size="2">388</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Shades only</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">389</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">undefined</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Modification for BW views</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillBlip</font><p></p></td><td valign="top"><font face=" , " size="2">390</font><p></p></td><td valign="top"><font face=" , " size="2">IMsoBlip*</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Pattern/texture</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillBlipName</font><p></p></td><td valign="top"><font face=" , " size="2">391</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip file name</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillBlipFlags</font><p></p></td><td valign="top"><font face=" , " size="2">392</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBLIPFLAGS</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Comment</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Blip flags</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillWidth</font><p></p></td><td valign="top"><font face=" , " size="2">393</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">How big (A units) to make a metafile texture.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillHeight</font><p></p></td><td valign="top"><font face=" , " size="2">394</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillAngle</font><p></p></td><td valign="top"><font face=" , " size="2">395</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fade angle - degrees in 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillFocus</font><p></p></td><td valign="top"><font face=" , " size="2">396</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Linear shaded fill focus percent</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillToLeft</font><p></p></td><td valign="top"><font face=" , " size="2">397</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fraction 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillToTop</font><p></p></td><td valign="top"><font face=" , " size="2">398</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fraction 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillToRight</font><p></p></td><td valign="top"><font face=" , " size="2">399</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fraction 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillToBottom</font><p></p></td><td valign="top"><font face=" , " size="2">400</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fraction 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillRectLeft</font><p></p></td><td valign="top"><font face=" , " size="2">401</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">For shaded fills, use the specified rectangle instead of the shape's bounding rect to define how large the fade is going to be.</font><p></p>
+<p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillRectTop</font><p></p></td><td valign="top"><font face=" , " size="2">402</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillRectRight</font><p></p></td><td valign="top"><font face=" , " size="2">403</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillRectBottom</font><p></p></td><td valign="top"><font face=" , " size="2">404</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillDztype</font><p></p></td><td valign="top"><font face=" , " size="2">405</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSODZTYPE</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Default</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillShadePreset</font><p></p></td><td valign="top"><font face=" , " size="2">406</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Special shades</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillShadeColors</font><p></p></td><td valign="top"><font face=" , " size="2">407</font><p></p></td><td valign="top"><font face=" , " size="2"><b>IMsoArray</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">a preset array of colors</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillOriginX</font><p></p></td><td valign="top"><font face=" , " size="2">408</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillOriginY</font><p></p></td><td valign="top"><font face=" , " size="2">409</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillShapeOriginX</font><p></p></td><td valign="top"><font face=" , " size="2">410</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillShapeOriginY</font><p></p></td><td valign="top"><font face=" , " size="2">411</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillShadeType</font><p></p></td><td valign="top"><font face=" , " size="2">412</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOSHADETYPE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Type of shading, if a shaded (gradient) fill.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fFilled</font><p></p></td><td valign="top"><font face=" , " size="2">443</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Is shape filled?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fHitTestFill</font><p></p></td><td valign="top"><font face=" , " size="2">444</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Should we hit test fill? </font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillShape</font><p></p></td><td valign="top"><font face=" , " size="2">445</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Register pattern on shape</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fillUseRect</font><p></p></td><td valign="top"><font face=" , " size="2">446</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Use the large rect?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fNoFillHitTest</font><p></p></td><td valign="top"><font face=" , " size="2">447</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Hit test a shape as though filled<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineColor</font><p></p></td><td valign="top"><font face=" , " size="2">448</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">black</font><p></p></td><td valign="top"><font face=" , " size="2">Color of line</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineOpacity</font><p></p></td><td valign="top"><font face=" , " size="2">449</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2">Not implemented</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineBackColor</font><p></p></td><td valign="top"><font face=" , " size="2">450</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">white</font><p></p></td><td valign="top"><font face=" , " size="2">Background color</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">451</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">undefined</font><p></p></td><td valign="top"><font face=" , " size="2">Modification for BW views</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineType</font><p></p></td><td valign="top"><font face=" , " size="2">452</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINETYPE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Solid</font><p></p></td><td valign="top"><font face=" , " size="2">Type of line</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillBlip</font><p></p></td><td valign="top"><font face=" , " size="2">453</font><p></p></td><td valign="top"><font face=" , " size="2">IMsoBlip*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">Pattern/texture</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillBlipName</font><p></p></td><td valign="top"><font face=" , " size="2">454</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">Blip file name</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillBlipFlags</font><p></p></td><td valign="top"><font face=" , " size="2">455</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBLIPFLAGS</b></font><p></p></td><td valign="top"><font face=" , " size="2">Comment</font><p></p></td><td valign="top"><font face=" , " size="2">Blip flags</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillWidth</font><p></p></td><td valign="top"><font face=" , " size="2">456</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">How big (A units) to make a metafile texture.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillHeight</font><p></p></td><td valign="top"><font face=" , " size="2">457</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillDztype</font><p></p></td><td valign="top"><font face=" , " size="2">458</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSODZTYPE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">How to interpret fillWidth/Height numbers.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineWidth</font><p></p></td><td valign="top"><font face=" , " size="2">459</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">9525</font><p></p></td><td valign="top"><font face=" , " size="2">A units; 1pt == 12700 EMUs</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineMiterLimit</font><p></p></td><td valign="top"><font face=" , " size="2">460</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">8<<16</font><p></p></td><td valign="top"><font face=" , " size="2">ratio (16.16) of width</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineStyle</font><p></p></td><td valign="top"><font face=" , " size="2">461</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINESTYLE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Simple</font><p></p></td><td valign="top"><font face=" , " size="2">Draw parallel lines?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineDashing</font><p></p></td><td valign="top"><font face=" , " size="2">462</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEDASHING</b></font><p></p></td><td valign="top"><font face=" , " size="2">Solid</font><p></p></td><td valign="top"><font face=" , " size="2">Can be overridden by:</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineDashStyle</font><p></p></td><td valign="top"><font face=" , " size="2">463</font><p></p></td><td valign="top"><font face=" , " size="2"><b>IMsoArray</b></font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">As Win32 ExtCreatePen</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineStartArrowhead</font><p></p></td><td valign="top"><font face=" , " size="2">464</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEEND</b></font><p></p></td><td valign="top"><font face=" , " size="2">NoEnd</font><p></p></td><td valign="top"><font face=" , " size="2">Arrow at start</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineEndArrowhead</font><p></p></td><td valign="top"><font face=" , " size="2">465</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEEND</b></font><p></p></td><td valign="top"><font face=" , " size="2">NoEnd</font><p></p></td><td valign="top"><font face=" , " size="2">Arrow at end</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineStartArrowWidth</font><p></p></td><td valign="top"><font face=" , " size="2">466</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEENDWIDTH</b></font><p></p></td><td valign="top"><font face=" , " size="2">MediumWidthArrow</font><p></p></td><td valign="top"><font face=" , " size="2">Arrow at start</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineStartArrowLength</font><p></p></td><td valign="top"><font face=" , " size="2">467</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEENDLENGTH</b></font><p></p></td><td valign="top"><font face=" , " size="2">MediumLenArrow</font><p></p></td><td valign="top"><font face=" , " size="2">Arrow at end</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineEndArrowWidth</font><p></p></td><td valign="top"><font face=" , " size="2">468</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEENDWIDTH</b></font><p></p></td><td valign="top"><font face=" , " size="2">MediumWidthArrow</font><p></p></td><td valign="top"><font face=" , " size="2">Arrow at start</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineEndArrowLength</font><p></p></td><td valign="top"><font face=" , " size="2">469</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEENDLENGTH</b></font><p></p></td><td valign="top"><font face=" , " size="2">MediumLenArrow</font><p></p></td><td valign="top"><font face=" , " size="2">Arrow at end</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineJoinStyle</font><p></p></td><td valign="top"><font face=" , " size="2">470</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINEJOIN</b></font><p></p></td><td valign="top"><font face=" , " size="2">JoinRound</font><p></p></td><td valign="top"><font face=" , " size="2">How to join lines</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineEndCapStyle</font><p></p></td><td valign="top"><font face=" , " size="2">471</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOLINECAP</b></font><p></p></td><td valign="top"><font face=" , " size="2">EndCapFlat</font><p></p></td><td valign="top"><font face=" , " size="2">How to end lines</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fArrowheadsOK</font><p></p></td><td valign="top"><font face=" , " size="2">507</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Allow arrowheads if prop. is set</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLine</font><p></p></td><td valign="top"><font face=" , " size="2">508</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2">Any line?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fHitTestLine</font><p></p></td><td valign="top"><font face=" , " size="2">509</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2">Should we hit test lines? </font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lineFillShape</font><p></p></td><td valign="top"><font face=" , " size="2">510</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2">Register pattern on shape</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fNoLineDrawDash</font><p></p></td><td valign="top"><font face=" , " size="2">511</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Draw a dashed line if no line<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowType</font><p></p></td><td valign="top"><font face=" , " size="2">512</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOSHADOWTYPE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Offset</font><p></p></td><td valign="top"><font face=" , " size="2">Type of effect</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowColor</font><p></p></td><td valign="top"><font face=" , " size="2">513</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">0x808080</font><p></p></td><td valign="top"><font face=" , " size="2">Foreground color</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowHighlight</font><p></p></td><td valign="top"><font face=" , " size="2">514</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">0xCBCBCB</font><p></p></td><td valign="top"><font face=" , " size="2">Embossed color</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">515</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">undefined</font><p></p></td><td valign="top"><font face=" , " size="2">Modification for BW views</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowOpacity</font><p></p></td><td valign="top"><font face=" , " size="2">516</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2">Fixed 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowOffsetX</font><p></p></td><td valign="top"><font face=" , " size="2">517</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">25400</font><p></p></td><td valign="top"><font face=" , " size="2">Offset shadow</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowOffsetY</font><p></p></td><td valign="top"><font face=" , " size="2">518</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">25400</font><p></p></td><td valign="top"><font face=" , " size="2">Offset shadow</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowSecondOffsetX</font><p></p></td><td valign="top"><font face=" , " size="2">519</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Double offset shadow</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowSecondOffsetY</font><p></p></td><td valign="top"><font face=" , " size="2">520</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Double offset shadow</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowScaleXToX</font><p></p></td><td valign="top"><font face=" , " size="2">521</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2">16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowScaleYToX</font><p></p></td><td valign="top"><font face=" , " size="2">522</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowScaleXToY</font><p></p></td><td valign="top"><font face=" , " size="2">523</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowScaleYToY</font><p></p></td><td valign="top"><font face=" , " size="2">524</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2">16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowPerspectiveX</font><p></p></td><td valign="top"><font face=" , " size="2">525</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">16.16 / weight</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowPerspectiveY</font><p></p></td><td valign="top"><font face=" , " size="2">526</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">16.16 / weight</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowWeight</font><p></p></td><td valign="top"><font face=" , " size="2">527</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<8</font><p></p></td><td valign="top"><font face=" , " size="2">scaling factor</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowOriginX</font><p></p></td><td valign="top"><font face=" , " size="2">528</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">shadowOriginY</font><p></p></td><td valign="top"><font face=" , " size="2">529</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fShadow</font><p></p></td><td valign="top"><font face=" , " size="2">574</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Any shadow?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fshadowObscured</font><p></p></td><td valign="top"><font face=" , " size="2">575</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Excel5-style shadow<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveType</font><p></p></td><td valign="top"><font face=" , " size="2">576</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOXFORMTYPE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Shape</font><p></p></td><td valign="top"><font face=" , " size="2">Where transform applies</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveOffsetX</font><p></p></td><td valign="top"><font face=" , " size="2">577</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">The LONG values define a transformation matrix, effectively, each value is scaled by the perspectiveWeight parameter.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveOffsetY</font><p></p></td><td valign="top"><font face=" , " size="2">578</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveScaleXToX</font><p></p></td><td valign="top"><font face=" , " size="2">579</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveScaleYToX</font><p></p></td><td valign="top"><font face=" , " size="2">580</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveScaleXToY</font><p></p></td><td valign="top"><font face=" , " size="2">581</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveScaleYToY</font><p></p></td><td valign="top"><font face=" , " size="2">582</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<16</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectivePerspectiveX</font><p></p></td><td valign="top"><font face=" , " size="2">583</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectivePerspectiveY</font><p></p></td><td valign="top"><font face=" , " size="2">584</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveWeight</font><p></p></td><td valign="top"><font face=" , " size="2">585</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<8</font><p></p></td><td valign="top"><font face=" , " size="2">Scaling factor</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveOriginX</font><p></p></td><td valign="top"><font face=" , " size="2">586</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<15</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">perspectiveOriginY</font><p></p></td><td valign="top"><font face=" , " size="2">587</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1<<15</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fPerspective</font><p></p></td><td valign="top"><font face=" , " size="2">639</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">On/off<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="6"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="0"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Default</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DSpecularAmt</font><p></p></td><td valign="top"><font face=" , " size="2">640</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fixed-point 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DDiffuseAmt</font><p></p></td><td valign="top"><font face=" , " size="2">641</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">65536</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Fixed-point 16.16</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DShininess</font><p></p></td><td valign="top"><font face=" , " size="2">642</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">5</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Default gives OK results</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DEdgeThickness</font><p></p></td><td valign="top"><font face=" , " size="2">643</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">12700</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Specular edge thickness</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DExtrudeForward</font><p></p></td><td valign="top"><font face=" , " size="2">644</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Distance of extrusion in EMUs</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DExtrudeBackward</font><p></p></td><td valign="top"><font face=" , " size="2">645</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">457200</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DExtrudePlane</font><p></p></td><td valign="top"><font face=" , " size="2">646</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Extrusion direction</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DExtrusionColor</font><p></p></td><td valign="top"><font face=" , " size="2">647</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td valign="top"><font face=" , " size="2">FillThenLine</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Basic color of extruded part of shape; the lighting model used will determine the exact shades used when rendering. </font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DCrMod</font><p></p></td><td valign="top"><font face=" , " size="2">648</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCLR</b></font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">undefined</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Modification for BW views</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">f3D</font><p></p></td><td valign="top"><font face=" , " size="2">700</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Does this shape have a 3D effect?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DMetallic</font><p></p></td><td valign="top"><font face=" , " size="2">701</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">0</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Use metallic specularity?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DUseExtrusionColor</font><p></p></td><td valign="top"><font face=" , " size="2">702</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DLightFace</font><p></p></td><td valign="top"><font face=" , " size="2">703</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"><p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DYRotationAngle</font><p></p></td><td valign="top"><font face=" , " size="2">704</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">degrees (16.16) about y axis</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DXRotationAngle</font><p></p></td><td valign="top"><font face=" , " size="2">705</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">degrees (16.16) about x axis</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationAxisX</font><p></p></td><td valign="top"><font face=" , " size="2">706</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">100</font><p></p></td><td valign="top"><font face=" , " size="2">These specify the rotation axis; only their relative magnitudes matter.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationAxisY</font><p></p></td><td valign="top"><font face=" , " size="2">707</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationAxisZ</font><p></p></td><td valign="top"><font face=" , " size="2">708</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationAngle</font><p></p></td><td valign="top"><font face=" , " size="2">709</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">degrees (16.16) about axis</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationCenterX</font><p></p></td><td valign="top"><font face=" , " size="2">710</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">rotation center x (16.16 or g-units)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationCenterY</font><p></p></td><td valign="top"><font face=" , " size="2">711</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">rotation center y (16.16 or g-units)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRotationCenterZ</font><p></p></td><td valign="top"><font face=" , " size="2">712</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">rotation center z (absolute (emus))</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DRenderMode</font><p></p></td><td valign="top"><font face=" , " size="2">713</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSO3DRENDERMODE</b></font><p></p></td><td valign="top"><font face=" , " size="2">FullRender</font><p></p></td><td valign="top"><font face=" , " size="2">Full,wireframe, or bcube</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DTolerance</font><p></p></td><td valign="top"><font face=" , " size="2">714</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">30000</font><p></p></td><td valign="top"><font face=" , " size="2">pixels (16.16)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DXViewpoint</font><p></p></td><td valign="top"><font face=" , " size="2">715</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1250000</font><p></p></td><td valign="top"><font face=" , " size="2">X view point (emus)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DYViewpoint</font><p></p></td><td valign="top"><font face=" , " size="2">716</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">-1250000</font><p></p></td><td valign="top"><font face=" , " size="2">Y view point (emus)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DZViewpoint</font><p></p></td><td valign="top"><font face=" , " size="2">717</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">9000000</font><p></p></td><td valign="top"><font face=" , " size="2">Z view distance (emus)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DOriginX</font><p></p></td><td valign="top"><font face=" , " size="2">718</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">32768</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DOriginY</font><p></p></td><td valign="top"><font face=" , " size="2">719</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">-32768</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DSkewAngle</font><p></p></td><td valign="top"><font face=" , " size="2">720</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">-8847360</font><p></p></td><td valign="top"><font face=" , " size="2">degree (16.16) skew angle</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DSkewAmount</font><p></p></td><td valign="top"><font face=" , " size="2">721</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">50</font><p></p></td><td valign="top"><font face=" , " size="2">Percentage skew amount</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DAmbientIntensity</font><p></p></td><td valign="top"><font face=" , " size="2">722</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">20000</font><p></p></td><td valign="top"><font face=" , " size="2">Fixed point intensity</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DKeyX</font><p></p></td><td valign="top"><font face=" , " size="2">723</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">50000</font><p></p></td><td valign="top"><font face=" , " size="2">Key light source direc-</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DKeyY</font><p></p></td><td valign="top"><font face=" , " size="2">724</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">tion; only their relative</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DKeyZ</font><p></p></td><td valign="top"><font face=" , " size="2">725</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">10000</font><p></p></td><td valign="top"><font face=" , " size="2">magnitudes matter</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DKeyIntensity</font><p></p></td><td valign="top"><font face=" , " size="2">726</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">38000</font><p></p></td><td valign="top"><font face=" , " size="2">Fixed point intensity</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DFillX</font><p></p></td><td valign="top"><font face=" , " size="2">727</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">-50000</font><p></p></td><td valign="top"><font face=" , " size="2">Fill light source direc-</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DFillY</font><p></p></td><td valign="top"><font face=" , " size="2">728</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">tion; only their relative</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DFillZ</font><p></p></td><td valign="top"><font face=" , " size="2">729</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">10000</font><p></p></td><td valign="top"><font face=" , " size="2">magnitudes matter</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">c3DFillIntensity</font><p></p></td><td valign="top"><font face=" , " size="2">730</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">38000</font><p></p></td><td valign="top"><font face=" , " size="2">Fixed point intensity</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DConstrainRotation</font><p></p></td><td valign="top"><font face=" , " size="2">763</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DRotationCenterAuto</font><p></p></td><td valign="top"><font face=" , " size="2">764</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DParallel</font><p></p></td><td valign="top"><font face=" , " size="2">765</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">1</font><p></p></td><td valign="top"><font face=" , " size="2">Parallel projection?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DKeyHarsh</font><p></p></td><td valign="top"><font face=" , " size="2">766</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">1</font><p></p></td><td valign="top"><font face=" , " size="2">Is key lighting harsh?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fc3DFillHarsh</font><p></p></td><td valign="top"><font face=" , " size="2">767</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Is fill lighting harsh?<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="6"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="0"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Default</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">hspMaster</font><p></p></td><td valign="top"><font face=" , " size="2">769</font><p></p></td><td valign="top"><font face=" , " size="2">MSOHSP</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">NULL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">master shape</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">cxstyle</font><p></p></td><td valign="top"><font face=" , " size="2">771</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOCXSTYLE</b></font><p></p></td><td valign="top"><font face=" , " size="2">None</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Type of connector</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">bWMode</font><p></p></td><td valign="top"><font face=" , " size="2">772</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBWMODE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Automatic</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Settings for modifications to be made when in different forms of black-and-white mode.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">bWModePureBW</font><p></p></td><td valign="top"><font face=" , " size="2">773</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBWMODE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Automatic</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">bWModeBW</font><p></p></td><td valign="top"><font face=" , " size="2">774</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOBWMODE</b></font><p></p></td><td valign="top"><font face=" , " size="2">Automatic</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fOleIcon</font><p></p></td><td valign="top"><font face=" , " size="2">826</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">For OLE objects, whether the object is in icon form</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fPreferRelativeResize</font><p></p></td><td valign="top"><font face=" , " size="2">827</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">For UI only. Prefer relative resizing. </font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fLockShapeType</font><p></p></td><td valign="top"><font face=" , " size="2">828</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">Lock the shape type (don't allow Change Shape)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fDeleteAttachedObject</font><p></p></td><td valign="top"><font face=" , " size="2">830</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fBackground</font><p></p></td><td valign="top"><font face=" , " size="2">831</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td colspan="2" valign="top"><font face=" , " size="2">If TRUE, this is the background shape.<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">spcot</font><p></p></td><td valign="top"><font face=" , " size="2">832</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOSPCOT</b></font><p></p></td><td valign="top"><font face=" , " size="2">TwoSegment</font><p></p></td><td valign="top"><font face=" , " size="2">Callout type</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxyCalloutGap</font><p></p></td><td valign="top"><font face=" , " size="2">833</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/12 inch</font><p></p></td><td valign="top"><font face=" , " size="2">Distance from box to first point.(EMUs)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">spcoa</font><p></p></td><td valign="top"><font face=" , " size="2">834</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOSPCOA</b></font><p></p></td><td valign="top"><font face=" , " size="2">Any</font><p></p></td><td valign="top"><font face=" , " size="2">Callout angle</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">spcod</font><p></p></td><td valign="top"><font face=" , " size="2">835</font><p></p></td><td valign="top"><font face=" , " size="2"><b>MSOSPCOD</b></font><p></p></td><td valign="top"><font face=" , " size="2">Specified</font><p></p></td><td valign="top"><font face=" , " size="2">Callout drop type</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxyCalloutDropSpecified</font><p></p></td><td valign="top"><font face=" , " size="2">836</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">9 points</font><p></p></td><td valign="top"><font face=" , " size="2">if msospcodSpecified, the actual drop distance</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxyCalloutLengthSpecified</font><p></p></td><td valign="top"><font face=" , " size="2">837</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">if fCalloutLengthSpecified, the actual distance</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCallout</font><p></p></td><td valign="top"><font face=" , " size="2">889</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Is the shape a callout?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCalloutAccentBar</font><p></p></td><td valign="top"><font face=" , " size="2">890</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">does callout have accent bar</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCalloutTextBorder</font><p></p></td><td valign="top"><font face=" , " size="2">891</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2">does callout have a text border</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCalloutMinusX</font><p></p></td><td valign="top"><font face=" , " size="2">892</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCalloutMinusY</font><p></p></td><td valign="top"><font face=" , " size="2">893</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2"></font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCalloutDropAuto</font><p></p></td><td valign="top"><font face=" , " size="2">894</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">If true, then we occasionally invert the drop distance</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fCalloutLengthSpecified</font><p></p></td><td valign="top"><font face=" , " size="2">895</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">if true, we look at dxyCalloutLengthSpecified<p></p></font></td></tr></tbody></table> +<table border="0" cellpadding="7" cols="5"><colgroup><col valign="top" width="115"><col valign="top" width="21"><col valign="top" width="50"><col valign="top" width="50"><col valign="top" width="195"></colgroup><tbody><tr><td valign="top"><font face=" , " size="2">Property</font><p></p></td><td valign="top"><font face=" , " size="2">PID</font><p></p></td><td valign="top"><font face=" , " size="2">Type</font><p></p></td><td valign="top"><font face=" , " size="2">Default</font><p></p></td><td valign="top"><font face=" , " size="2">Description</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">wzName</font><p></p></td><td valign="top"><font face=" , " size="2">896</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">Shape Name (present only if explicitly set)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">wzDescription</font><p></p></td><td valign="top"><font face=" , " size="2">897</font><p></p></td><td valign="top"><font face=" , " size="2">WCHAR*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">alternate text</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pihlShape</font><p></p></td><td valign="top"><font face=" , " size="2">898</font><p></p></td><td valign="top"><font face=" , " size="2">IHlink*</font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">The hyperlink in the shape.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">pWrapPolygonVertices</font><p></p></td><td valign="top"><font face=" , " size="2">899</font><p></p></td><td valign="top"><font face=" , " size="2"><b>IMsoArray</b></font><p></p></td><td valign="top"><font face=" , " size="2">NULL</font><p></p></td><td valign="top"><font face=" , " size="2">The polygon that text will be wrapped around (Word)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxWrapDistLeft</font><p></p></td><td valign="top"><font face=" , " size="2">900</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/8 inch</font><p></p></td><td valign="top"><font face=" , " size="2">Left wrapping distance from text (Word)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dyWrapDistTop</font><p></p></td><td valign="top"><font face=" , " size="2">901</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Top wrapping distance from text (Word)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dxWrapDistRight</font><p></p></td><td valign="top"><font face=" , " size="2">902</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">1/8 inch</font><p></p></td><td valign="top"><font face=" , " size="2">Right wrapping distance from text (Word)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">dyWrapDistBottom</font><p></p></td><td valign="top"><font face=" , " size="2">903</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Bottom wrapping distance from text (Word)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">lidRegroup</font><p></p></td><td valign="top"><font face=" , " size="2">904</font><p></p></td><td valign="top"><font face=" , " size="2">LONG</font><p></p></td><td valign="top"><font face=" , " size="2">0</font><p></p></td><td valign="top"><font face=" , " size="2">Regroup ID </font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fEditedWrap</font><p></p></td><td valign="top"><font face=" , " size="2">953</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Has the wrap polygon been edited?</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fBehindDocument</font><p></p></td><td valign="top"><font face=" , " size="2">954</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Word-only (shape is behind text)</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fOnDblClickNotify</font><p></p></td><td valign="top"><font face=" , " size="2">955</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Notify client on a double click</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fIsButton</font><p></p></td><td valign="top"><font face=" , " size="2">956</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">A button shape (i.e., clicking performs an action). Set for shapes with attached hyperlinks or macros.</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fOneD</font><p></p></td><td valign="top"><font face=" , " size="2">957</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">1D adjustment</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fHidden</font><p></p></td><td valign="top"><font face=" , " size="2">958</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">FALSE</font><p></p></td><td valign="top"><font face=" , " size="2">Do not display</font><p></p></td></tr><tr><td valign="top"><font face=" , " size="2">fPrint</font><p></p></td><td valign="top"><font face=" , " size="2">959</font><p></p></td><td valign="top"><font face=" , " size="2">BOOL</font><p></p></td><td valign="top"><font face=" , " size="2">TRUE</font><p></p></td><td valign="top"><font face=" , " size="2">Print this shape</font><p></p></td></tr></tbody></table> + + <hr> + <address><a href="mailto:Henning.Brinkmann@sun.com">Henning Brinkmann - Sun Germany - Software Engineer</a></address> +<!-- Created: Mon Jul 10 13:57:58 CEST 2006 --> +<!-- hhmts start --> +Last modified: Mon Jul 10 17:55:06 CEST 2006 +<!-- hhmts end --> + </body> +</html> diff --git a/writerfilter/source/doctok/escherdoc.xsl b/writerfilter/source/doctok/escherdoc.xsl new file mode 100644 index 000000000000..04a63865e9c3 --- /dev/null +++ b/writerfilter/source/doctok/escherdoc.xsl @@ -0,0 +1,145 @@ +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default" xmlns:xhtml="http://www.w3.org/1999/xhtml"> +<xsl:output method="xml" indent="yes"/> + +<xsl:template match="/"> + <out> + <xsl:for-each select="//xhtml:table"> + <xsl:apply-templates select="." mode="eschertable"/> + </xsl:for-each> + </out> +</xsl:template> + +<xsl:template match="xhtml:table" mode="eschertable"> + <xsl:apply-templates select=".//xhtml:tr[position() > 1]" mode="eschertable"/> +</xsl:template> + +<xsl:template match="xhtml:tr" mode="eschertable"> + <xsl:variable name="name"> + <xsl:value-of select=".//xhtml:td[1]"/> + </xsl:variable> + <UML:Class> + <xsl:attribute name="xmi.id"> + <xsl:value-of select="$name"/> + </xsl:attribute> + <xsl:attribute name="name"> + <xsl:value-of select="$name"/> + </xsl:attribute> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt" /> + </UML:ModelElement.stereotype> + <xsl:apply-templates select=".//xhtml:td[1]" mode="optname"/> + <xsl:apply-templates select=".//xhtml:td[2]" mode="fopid"/> + <xsl:apply-templates select=".//xhtml:td[3]" mode="type"/> + <xsl:apply-templates select=".//xhtml:td[4]" mode="default"/> + <xsl:apply-templates select=".//xhtml:td[5]" mode="comment"/> + </UML:Class> +</xsl:template> + +<xsl:template match="xhtml:td" mode="optname"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shp<xsl:value-of select="."/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> +</xsl:template> + +<xsl:template match="xhtml:td" mode="fopid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="."/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> +</xsl:template> + +<xsl:template match="xhtml:td" mode="type"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:call-template name="saltype"> + <xsl:with-param name="type" select="."/> + </xsl:call-template> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <xsl:if test=".='BOOL'"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </xsl:if> +</xsl:template> + +<xsl:template match="xhtml:td" mode="default"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="."/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> +</xsl:template> + +<xsl:template match="xhtml:td" mode="comment"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue><xsl:value-of select="."/></UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> +</xsl:template> + +<xsl:template name="saltype"> + <xsl:param name="type"/> + <xsl:choose> + <xsl:when test="$type='LONG'">U32</xsl:when> + <xsl:when test="$type='BOOL'">U8</xsl:when> + <xsl:when test="$type='WCHAR*'">String</xsl:when> + <xsl:otherwise>unknown</xsl:otherwise> + </xsl:choose> +</xsl:template> + +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/genqnametostr b/writerfilter/source/doctok/genqnametostr new file mode 100644 index 000000000000..a7cd32db5296 --- /dev/null +++ b/writerfilter/source/doctok/genqnametostr @@ -0,0 +1,33 @@ +#!/bin/tcsh +#************************************************************************ +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +# ***********************************************************************/ + +xalan -xsl qnametostr.xsl -in resources.xmi > qnametostr.tmp +cat qnametostrheader > qnametostr.cxx +cat qnametostr.tmp >> qnametostr.cxx +cat ../ooxml/qnametostr.tmp >> qnametostr.cxx +cat qnametostrfooter >> qnametostr.cxx diff --git a/writerfilter/source/doctok/makefile.mk b/writerfilter/source/doctok/makefile.mk new file mode 100644 index 000000000000..ff03079f2c7a --- /dev/null +++ b/writerfilter/source/doctok/makefile.mk @@ -0,0 +1,155 @@ +#************************************************************************ +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +# ***********************************************************************/ + +PRJ=..$/.. +PRJNAME=writerfilter +TARGET=doctok +#LIBTARGET=NO +ENABLE_EXCEPTIONS=TRUE +#USE_DEFFILE=TRUE +#EXTERNAL_WARNINGS_NOT_ERRORS=TRUE +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk +.INCLUDE : $(PRJ)$/inc$/writerfilter.mk + +#CFLAGS+=-DISOLATION_AWARE_ENABLED -DWIN32_LEAN_AND_MEAN -DXML_UNICODE -D_NTSDK -DUNICODE -D_UNICODE -D_WIN32_WINNT=0x0501 +#CFLAGS+=-wd4710 -wd4711 -wd4514 -wd4619 -wd4217 -wd4820 +#CDEFS+=-DDEBUG_DOCTOK_DUMP + + +# --- Files -------------------------------------------------------- + +SLOFILES= \ + $(SLO)$/WW8Annotation.obj \ + $(SLO)$/WW8OutputWithDepth.obj \ + $(SLO)$/WW8Text.obj \ + $(SLO)$/DffImpl.obj \ + $(SLO)$/Dff.obj \ + $(SLO)$/WW8Picture.obj \ + $(SLO)$/WW8Sttbf.obj \ + $(SLO)$/WW8Table.obj \ + $(SLO)$/WW8StyleSheet.obj \ + $(SLO)$/WW8FontTable.obj \ + $(SLO)$/WW8LFOTable.obj \ + $(SLO)$/WW8ListTable.obj \ + $(SLO)$/resources.obj \ + $(SLO)$/WW8CpAndFc.obj \ + $(SLO)$/WW8StructBase.obj \ + $(SLO)$/WW8Clx.obj \ + $(SLO)$/WW8FKPImpl.obj \ + $(SLO)$/WW8BinTableImpl.obj \ + $(SLO)$/WW8StreamImpl.obj \ + $(SLO)$/WW8PropertySetImpl.obj \ + $(SLO)$/WW8DocumentImpl.obj \ + $(SLO)$/WW8PieceTableImpl.obj \ + $(SLO)$/WW8ResourceModelImpl.obj + + +SHL1TARGET=$(TARGET) + +.IF "$(GUI)"=="UNX" || "$(GUI)"=="MAC" +RESOURCEMODELLIB=-lresourcemodel +.ELIF "$(GUI)"=="OS2" +RESOURCEMODELLIB=$(LB)$/iresourcemodel.lib +.ELIF "$(GUI)"=="WNT" +.IF "$(COM)"=="GCC" +RESOURCEMODELLIB=-lresourcemodel +.ELSE +RESOURCEMODELLIB=$(LB)$/iresourcemodel.lib +.ENDIF +.ENDIF + + +SHL1STDLIBS=$(SALLIB)\ + $(CPPULIB)\ + $(CPPUHELPERLIB) \ + $(RESOURCEMODELLIB) +SHL1IMPLIB=i$(SHL1TARGET) +SHL1USE_EXPORTS=name + +SHL1OBJS=$(SLOFILES) + +SHL1DEF=$(MISC)$/$(SHL1TARGET).def +DEF1NAME=$(SHL1TARGET) +DEFLIB1NAME=$(TARGET) + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk + +DOCTOKHXXOUTDIR=$(INCCOM)/doctok +DOCTOKCXXOUTDIR=$(MISC) +DOCTOKHXXOUTDIRCREATED=$(DOCTOKHXXOUTDIR)/created + +DOCTOKMODEL=resources.xmi +DOCTOKRESOURCESXSL=resources.xsl +DOCTOKRESOURCESIMPLXSL=resourcesimpl.xsl +DOCTOKRESOURCEIDSXSL=resourceids.xsl +DOCTOKSPRMIDSXSL=sprmids.xsl +DOCTOKRESOURCETOOLS=resourcetools.xsl + +DOCTOKRESOURCEIDSHXX=$(DOCTOKHXXOUTDIR)$/resourceids.hxx +SPRMIDSHXX=$(DOCTOKHXXOUTDIR)$/sprmids.hxx +RESOURCESHXX=$(DOCTOKHXXOUTDIR)$/resources.hxx +RESOURCESCXX=$(DOCTOKCXXOUTDIR)$/resources.cxx + +DOCTOKGENHEADERS=$(DOCTOKRESOURCEIDSHXX) $(SPRMIDSHXX) $(RESOURCESHXX) +DOCTOKGENFILES=$(DOCTOKGENHEADERS) $(RESOURCESCXX) + +$(DOCTOKHXXOUTDIRCREATED): + @$(MKDIRHIER) $(DOCTOKHXXOUTDIR) + @$(TOUCH) $@ + +$(DOCTOKGENHEADERS): $(DOCTOKHXXOUTDIRCREATED) + +$(RESOURCESHXX): $(DOCTOKRESOURCESXSL) $(DOCTOKMODEL) + @echo "Making: " $(@:f) + $(COMMAND_ECHO)$(XSLTPROC) $(DOCTOKRESOURCESXSL) $(DOCTOKMODEL) > $@ + +$(SPRMIDSHXX): $(DOCTOKSPRMIDSXSL) $(DOCTOKMODEL) + @echo "Making: " $(@:f) + $(COMMAND_ECHO)$(XSLTPROC) $(DOCTOKSPRMIDSXSL) $(DOCTOKMODEL) > $@ + +$(RESOURCESCXX): $(DOCTOKRESOURCESIMPLXSL) $(DOCTOKMODEL) $(DOCTOKRESOURCEIDSHXX) $(DOCTOKRESOURCETOOLS) + @echo "Making: " $(@:f) + $(COMMAND_ECHO)$(XSLTPROC) $(DOCTOKRESOURCESIMPLXSL) $(DOCTOKMODEL) > $@ + +$(DOCTOKRESOURCEIDSHXX): $(DOCTOKRESOURCEIDSXSL) $(DOCTOKMODEL) + @echo "Making: " $(@:f) + $(COMMAND_ECHO)$(XSLTPROC) $(DOCTOKRESOURCEIDSXSL) $(DOCTOKMODEL) > $@ + +$(SLOFILES) : $(DOCTOKGENHEADERS) + +.PHONY: genmake genclean + +genmake: $(DOCTOKGENFILES) + +genclean: + rm -f $(DOCTOKGENFILES) + +genheaders: $(DOCTOKGENHEADERS) diff --git a/writerfilter/source/doctok/qnametostr.xsl b/writerfilter/source/doctok/qnametostr.xsl new file mode 100644 index 000000000000..44fca1e5dde5 --- /dev/null +++ b/writerfilter/source/doctok/qnametostr.xsl @@ -0,0 +1,41 @@ +<!-- +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output method="text" /> + +<xsl:include href="resourcetools.xsl"/> + +<xsl:template match="/"> + <xsl:apply-templates select=".//UML:Model" mode="qnametostr"/> + <xsl:apply-templates select='.//UML:Model' mode='sprmidstoxml'/> + <xsl:apply-templates select='.//UML:Model' mode='analyzerdoctokids'/> +</xsl:template> +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/qnametostrfooter b/writerfilter/source/doctok/qnametostrfooter new file mode 100644 index 000000000000..1ec35ed30254 --- /dev/null +++ b/writerfilter/source/doctok/qnametostrfooter @@ -0,0 +1,2 @@ +} +} diff --git a/writerfilter/source/doctok/qnametostrheader b/writerfilter/source/doctok/qnametostrheader new file mode 100644 index 000000000000..07ce47387153 --- /dev/null +++ b/writerfilter/source/doctok/qnametostrheader @@ -0,0 +1,36 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <doctok/resourceids.hxx> +#include <ooxml/resourceids.hxx> +#include "WW8ResourceModelImpl.hxx" + +namespace doctok +{ + +QNameToString::QNameToString() +{ diff --git a/writerfilter/source/doctok/replacesprmids b/writerfilter/source/doctok/replacesprmids new file mode 100755 index 000000000000..e4d6be329a4e --- /dev/null +++ b/writerfilter/source/doctok/replacesprmids @@ -0,0 +1,517 @@ + +#!/bin/sh + +sed "s/0xc601/NS_sprm::LN_PIstdPermute/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC601/NS_sprm::LN_PIstdPermute/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3644/NS_sprm::LN_TCantSplit/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3644/NS_sprm::LN_TCantSplit/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2602/NS_sprm::LN_PIncLvl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2602/NS_sprm::LN_PIncLvl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2461/NS_sprm::LN_PJcExtra/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2461/NS_sprm::LN_PJcExtra/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2403/NS_sprm::LN_PJc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2403/NS_sprm::LN_PJc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2404/NS_sprm::LN_PFSideBySide/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2404/NS_sprm::LN_PFSideBySide/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2405/NS_sprm::LN_PFKeep/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2405/NS_sprm::LN_PFKeep/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2406/NS_sprm::LN_PFKeepFollow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2406/NS_sprm::LN_PFKeepFollow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2407/NS_sprm::LN_PFPageBreakBefore/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2407/NS_sprm::LN_PFPageBreakBefore/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2408/NS_sprm::LN_PBrcl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2408/NS_sprm::LN_PBrcl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2409/NS_sprm::LN_PBrcp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2409/NS_sprm::LN_PBrcp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x260a/NS_sprm::LN_PIlvl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x260A/NS_sprm::LN_PIlvl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x460b/NS_sprm::LN_PIlfo/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x460B/NS_sprm::LN_PIlfo/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x240c/NS_sprm::LN_PFNoLineNumb/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x240C/NS_sprm::LN_PFNoLineNumb/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc60d/NS_sprm::LN_PChgTabsPapx/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC60D/NS_sprm::LN_PChgTabsPapx/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x840e/NS_sprm::LN_PDxaRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x840E/NS_sprm::LN_PDxaRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x840f/NS_sprm::LN_PDxaLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x840F/NS_sprm::LN_PDxaLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4610/NS_sprm::LN_PNest/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4610/NS_sprm::LN_PNest/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8411/NS_sprm::LN_PDxaLeft1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8411/NS_sprm::LN_PDxaLeft1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6412/NS_sprm::LN_PDyaLine/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6412/NS_sprm::LN_PDyaLine/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xa413/NS_sprm::LN_PDyaBefore/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xA413/NS_sprm::LN_PDyaBefore/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xa414/NS_sprm::LN_PDyaAfter/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xA414/NS_sprm::LN_PDyaAfter/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc615/NS_sprm::LN_PChgTabs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC615/NS_sprm::LN_PChgTabs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2416/NS_sprm::LN_PFInTable/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2416/NS_sprm::LN_PFInTable/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x244b/NS_sprm::LN_PCell/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x244B/NS_sprm::LN_PCell/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x244c/NS_sprm::LN_PRow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x244C/NS_sprm::LN_PRow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2417/NS_sprm::LN_PFTtp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2417/NS_sprm::LN_PFTtp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8418/NS_sprm::LN_PDxaAbs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8418/NS_sprm::LN_PDxaAbs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8419/NS_sprm::LN_PDyaAbs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8419/NS_sprm::LN_PDyaAbs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x841a/NS_sprm::LN_PDxaWidth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x841A/NS_sprm::LN_PDxaWidth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x261b/NS_sprm::LN_PPc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x261B/NS_sprm::LN_PPc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461c/NS_sprm::LN_PBrcTop10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461C/NS_sprm::LN_PBrcTop10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461d/NS_sprm::LN_PBrcLeft10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461D/NS_sprm::LN_PBrcLeft10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461e/NS_sprm::LN_PBrcBottom10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461E/NS_sprm::LN_PBrcBottom10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461f/NS_sprm::LN_PBrcRight10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x461F/NS_sprm::LN_PBrcRight10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4620/NS_sprm::LN_PBrcBetween10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4620/NS_sprm::LN_PBrcBetween10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4621/NS_sprm::LN_PBrcBar10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4621/NS_sprm::LN_PBrcBar10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4622/NS_sprm::LN_PDxaFromText10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4622/NS_sprm::LN_PDxaFromText10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2423/NS_sprm::LN_PWr/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2423/NS_sprm::LN_PWr/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6629/NS_sprm::LN_PBrcBar/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6629/NS_sprm::LN_PBrcBar/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x242a/NS_sprm::LN_PFNoAutoHyph/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x242A/NS_sprm::LN_PFNoAutoHyph/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x442b/NS_sprm::LN_PWHeightAbs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x442B/NS_sprm::LN_PWHeightAbs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x442c/NS_sprm::LN_PDcs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x442C/NS_sprm::LN_PDcs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x442d/NS_sprm::LN_PShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x442D/NS_sprm::LN_PShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x842e/NS_sprm::LN_PDyaFromText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x842E/NS_sprm::LN_PDyaFromText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x842f/NS_sprm::LN_PDxaFromText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x842F/NS_sprm::LN_PDxaFromText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2430/NS_sprm::LN_PFLocked/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2430/NS_sprm::LN_PFLocked/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2431/NS_sprm::LN_PFWidowControl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2431/NS_sprm::LN_PFWidowControl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc632/NS_sprm::LN_PRuler/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC632/NS_sprm::LN_PRuler/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2433/NS_sprm::LN_PFKinsoku/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2433/NS_sprm::LN_PFKinsoku/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2434/NS_sprm::LN_PFWordWrap/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2434/NS_sprm::LN_PFWordWrap/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2435/NS_sprm::LN_PFOverflowPunct/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2435/NS_sprm::LN_PFOverflowPunct/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2436/NS_sprm::LN_PFTopLinePunct/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2436/NS_sprm::LN_PFTopLinePunct/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2437/NS_sprm::LN_PFAutoSpaceDE/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2437/NS_sprm::LN_PFAutoSpaceDE/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2438/NS_sprm::LN_PFAutoSpaceDN/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2438/NS_sprm::LN_PFAutoSpaceDN/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4439/NS_sprm::LN_PWAlignFont/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4439/NS_sprm::LN_PWAlignFont/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x443a/NS_sprm::LN_PFrameTextFlow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x443A/NS_sprm::LN_PFrameTextFlow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x243b/NS_sprm::LN_PISnapBaseLine/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x243B/NS_sprm::LN_PISnapBaseLine/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc63e/NS_sprm::LN_PAnld/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC63E/NS_sprm::LN_PAnld/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc63f/NS_sprm::LN_PPropRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC63F/NS_sprm::LN_PPropRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2640/NS_sprm::LN_POutLvl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2640/NS_sprm::LN_POutLvl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2441/NS_sprm::LN_PFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2441/NS_sprm::LN_PFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2443/NS_sprm::LN_PFNumRMIns/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2443/NS_sprm::LN_PFNumRMIns/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2444/NS_sprm::LN_PCrLf/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2444/NS_sprm::LN_PCrLf/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc645/NS_sprm::LN_PNumRM/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC645/NS_sprm::LN_PNumRM/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6645/NS_sprm::LN_PHugePapx/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6645/NS_sprm::LN_PHugePapx/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2447/NS_sprm::LN_PFUsePgsuSettings/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2447/NS_sprm::LN_PFUsePgsuSettings/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2448/NS_sprm::LN_PFAdjustRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2448/NS_sprm::LN_PFAdjustRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0800/NS_sprm::LN_CFRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0800/NS_sprm::LN_CFRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0801/NS_sprm::LN_CFRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0801/NS_sprm::LN_CFRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0802/NS_sprm::LN_CFFldVanish/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0802/NS_sprm::LN_CFFldVanish/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6a03/NS_sprm::LN_CPicLocation/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6A03/NS_sprm::LN_CPicLocation/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4804/NS_sprm::LN_CIbstRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4804/NS_sprm::LN_CIbstRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6805/NS_sprm::LN_CDttmRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6805/NS_sprm::LN_CDttmRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0806/NS_sprm::LN_CFData/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0806/NS_sprm::LN_CFData/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4807/NS_sprm::LN_CIdslRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4807/NS_sprm::LN_CIdslRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xea08/NS_sprm::LN_CChs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xEA08/NS_sprm::LN_CChs/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6a09/NS_sprm::LN_CSymbol/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6A09/NS_sprm::LN_CSymbol/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x080a/NS_sprm::LN_CFOle2/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x080A/NS_sprm::LN_CFOle2/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x480b/NS_sprm::LN_CIdCharType/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x480B/NS_sprm::LN_CIdCharType/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a0c/NS_sprm::LN_CHighlight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A0C/NS_sprm::LN_CHighlight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x680e/NS_sprm::LN_CObjLocation/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x680E/NS_sprm::LN_CObjLocation/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a10/NS_sprm::LN_CFFtcAsciSymb/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A10/NS_sprm::LN_CFFtcAsciSymb/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a30/NS_sprm::LN_CIstd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A30/NS_sprm::LN_CIstd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca31/NS_sprm::LN_CIstdPermute/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA31/NS_sprm::LN_CIstdPermute/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a32/NS_sprm::LN_CDefault/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A32/NS_sprm::LN_CDefault/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a33/NS_sprm::LN_CPlain/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A33/NS_sprm::LN_CPlain/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a34/NS_sprm::LN_CKcd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A34/NS_sprm::LN_CKcd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0835/NS_sprm::LN_CFBold/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0835/NS_sprm::LN_CFBold/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0836/NS_sprm::LN_CFItalic/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0836/NS_sprm::LN_CFItalic/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0837/NS_sprm::LN_CFStrike/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0837/NS_sprm::LN_CFStrike/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0838/NS_sprm::LN_CFOutline/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0838/NS_sprm::LN_CFOutline/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0839/NS_sprm::LN_CFShadow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0839/NS_sprm::LN_CFShadow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x083a/NS_sprm::LN_CFSmallCaps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x083A/NS_sprm::LN_CFSmallCaps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x083b/NS_sprm::LN_CFCaps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x083B/NS_sprm::LN_CFCaps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x083c/NS_sprm::LN_CFVanish/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x083C/NS_sprm::LN_CFVanish/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a3d/NS_sprm::LN_CFtcDefault/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A3D/NS_sprm::LN_CFtcDefault/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a3e/NS_sprm::LN_CKul/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A3E/NS_sprm::LN_CKul/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xea3f/NS_sprm::LN_CSizePos/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xEA3F/NS_sprm::LN_CSizePos/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8840/NS_sprm::LN_CDxaSpace/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x8840/NS_sprm::LN_CDxaSpace/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a41/NS_sprm::LN_CLid/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A41/NS_sprm::LN_CLid/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a42/NS_sprm::LN_CIco/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A42/NS_sprm::LN_CIco/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a43/NS_sprm::LN_CHps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A43/NS_sprm::LN_CHps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a44/NS_sprm::LN_CHpsInc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A44/NS_sprm::LN_CHpsInc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4845/NS_sprm::LN_CHpsPos/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4845/NS_sprm::LN_CHpsPos/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a46/NS_sprm::LN_CHpsPosAdj/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A46/NS_sprm::LN_CHpsPosAdj/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca47/NS_sprm::LN_CMajority/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA47/NS_sprm::LN_CMajority/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a48/NS_sprm::LN_CIss/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A48/NS_sprm::LN_CIss/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca49/NS_sprm::LN_CHpsNew50/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA49/NS_sprm::LN_CHpsNew50/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca4a/NS_sprm::LN_CHpsInc1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA4A/NS_sprm::LN_CHpsInc1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x484b/NS_sprm::LN_CHpsKern/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x484B/NS_sprm::LN_CHpsKern/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca4c/NS_sprm::LN_CMajority50/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA4C/NS_sprm::LN_CMajority50/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a4d/NS_sprm::LN_CHpsMul/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A4D/NS_sprm::LN_CHpsMul/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x484e/NS_sprm::LN_CYsri/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x484E/NS_sprm::LN_CYsri/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a4f/NS_sprm::LN_CRgFtc0/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A4F/NS_sprm::LN_CRgFtc0/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a50/NS_sprm::LN_CRgFtc1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A50/NS_sprm::LN_CRgFtc1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a51/NS_sprm::LN_CRgFtc2/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A51/NS_sprm::LN_CRgFtc2/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4852/NS_sprm::LN_CCharScale/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4852/NS_sprm::LN_CCharScale/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2a53/NS_sprm::LN_CFDStrike/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2A53/NS_sprm::LN_CFDStrike/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0854/NS_sprm::LN_CFImprint/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0854/NS_sprm::LN_CFImprint/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0875/NS_sprm::LN_CFNoProof/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0875/NS_sprm::LN_CFNoProof/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0818/NS_sprm::LN_CFspecVanish/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0818/NS_sprm::LN_CFspecVanish/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca76/NS_sprm::LN_CFitText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA76/NS_sprm::LN_CFitText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x882/NS_sprm::LN_CComplexScript/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x882/NS_sprm::LN_CComplexScript/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2471/NS_sprm::LN_PTightWrap/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2471/NS_sprm::LN_PTightWrap/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0855/NS_sprm::LN_CFSpec/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0855/NS_sprm::LN_CFSpec/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0856/NS_sprm::LN_CFObj/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0856/NS_sprm::LN_CFObj/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca57/NS_sprm::LN_CPropRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA57/NS_sprm::LN_CPropRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0858/NS_sprm::LN_CFEmboss/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0858/NS_sprm::LN_CFEmboss/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2859/NS_sprm::LN_CSfxText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2859/NS_sprm::LN_CSfxText/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085a/NS_sprm::LN_CFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085A/NS_sprm::LN_CFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085b/NS_sprm::LN_CFDiacColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085B/NS_sprm::LN_CFDiacColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085c/NS_sprm::LN_CFBoldBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085C/NS_sprm::LN_CFBoldBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085d/NS_sprm::LN_CFItalicBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x085D/NS_sprm::LN_CFItalicBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a5e/NS_sprm::LN_CFtcBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A5E/NS_sprm::LN_CFtcBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x485f/NS_sprm::LN_CLidBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x485F/NS_sprm::LN_CLidBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a60/NS_sprm::LN_CIcoBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A60/NS_sprm::LN_CIcoBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4a61/NS_sprm::LN_CHpsBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4A61/NS_sprm::LN_CHpsBi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca62/NS_sprm::LN_CDispFldRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA62/NS_sprm::LN_CDispFldRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4863/NS_sprm::LN_CIbstRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4863/NS_sprm::LN_CIbstRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6864/NS_sprm::LN_CDttmRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6864/NS_sprm::LN_CDttmRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6865/NS_sprm::LN_CBrc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6865/NS_sprm::LN_CBrc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4866/NS_sprm::LN_CShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4866/NS_sprm::LN_CShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4867/NS_sprm::LN_CIdslRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x4867/NS_sprm::LN_CIdslRMarkDel/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0868/NS_sprm::LN_CFUsePgsuSettings/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x0868/NS_sprm::LN_CFUsePgsuSettings/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x486b/NS_sprm::LN_CCpg/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x486B/NS_sprm::LN_CCpg/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x486d/NS_sprm::LN_CRgLid0/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x486D/NS_sprm::LN_CRgLid0/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x486e/NS_sprm::LN_CRgLid1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x486E/NS_sprm::LN_CRgLid1/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x286f/NS_sprm::LN_CIdctHint/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x286F/NS_sprm::LN_CIdctHint/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2e00/NS_sprm::LN_PicBrcl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x2E00/NS_sprm::LN_PicBrcl/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xce01/NS_sprm::LN_PicScale/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCE01/NS_sprm::LN_PicScale/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6c02/NS_sprm::LN_PicBrcTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6C02/NS_sprm::LN_PicBrcTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6c03/NS_sprm::LN_PicBrcLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6C03/NS_sprm::LN_PicBrcLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6c04/NS_sprm::LN_PicBrcBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6C04/NS_sprm::LN_PicBrcBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6c05/NS_sprm::LN_PicBrcRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6C05/NS_sprm::LN_PicBrcRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3000/NS_sprm::LN_ScnsPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3000/NS_sprm::LN_ScnsPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3001/NS_sprm::LN_SiHeadingPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3001/NS_sprm::LN_SiHeadingPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd202/NS_sprm::LN_SOlstAnm/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD202/NS_sprm::LN_SOlstAnm/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xf203/NS_sprm::LN_SDxaColWidth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xF203/NS_sprm::LN_SDxaColWidth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xf204/NS_sprm::LN_SDxaColSpacing/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xF204/NS_sprm::LN_SDxaColSpacing/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3005/NS_sprm::LN_SFEvenlySpaced/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3005/NS_sprm::LN_SFEvenlySpaced/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3006/NS_sprm::LN_SFProtected/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3006/NS_sprm::LN_SFProtected/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5007/NS_sprm::LN_SDmBinFirst/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5007/NS_sprm::LN_SDmBinFirst/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5008/NS_sprm::LN_SDmBinOther/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5008/NS_sprm::LN_SDmBinOther/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3009/NS_sprm::LN_SBkc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3009/NS_sprm::LN_SBkc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x300a/NS_sprm::LN_SFTitlePage/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x300A/NS_sprm::LN_SFTitlePage/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x500b/NS_sprm::LN_SCcolumns/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x500B/NS_sprm::LN_SCcolumns/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x900c/NS_sprm::LN_SDxaColumns/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x900C/NS_sprm::LN_SDxaColumns/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x300d/NS_sprm::LN_SFAutoPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x300D/NS_sprm::LN_SFAutoPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x300e/NS_sprm::LN_SNfcPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x300E/NS_sprm::LN_SNfcPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb00f/NS_sprm::LN_SDyaPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB00F/NS_sprm::LN_SDyaPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb010/NS_sprm::LN_SDxaPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB010/NS_sprm::LN_SDxaPgn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3011/NS_sprm::LN_SFPgnRestart/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3011/NS_sprm::LN_SFPgnRestart/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3012/NS_sprm::LN_SFEndnote/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3012/NS_sprm::LN_SFEndnote/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3013/NS_sprm::LN_SLnc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3013/NS_sprm::LN_SLnc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3014/NS_sprm::LN_SGprfIhdt/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3014/NS_sprm::LN_SGprfIhdt/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5015/NS_sprm::LN_SNLnnMod/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5015/NS_sprm::LN_SNLnnMod/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9016/NS_sprm::LN_SDxaLnn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9016/NS_sprm::LN_SDxaLnn/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb017/NS_sprm::LN_SDyaHdrTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB017/NS_sprm::LN_SDyaHdrTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb018/NS_sprm::LN_SDyaHdrBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB018/NS_sprm::LN_SDyaHdrBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3019/NS_sprm::LN_SLBetween/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3019/NS_sprm::LN_SLBetween/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x301a/NS_sprm::LN_SVjc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x301A/NS_sprm::LN_SVjc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x501b/NS_sprm::LN_SLnnMin/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x501B/NS_sprm::LN_SLnnMin/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x501c/NS_sprm::LN_SPgnStart/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x501C/NS_sprm::LN_SPgnStart/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x301d/NS_sprm::LN_SBOrientation/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x301D/NS_sprm::LN_SBOrientation/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x301e/NS_sprm::LN_SBCustomize/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x301E/NS_sprm::LN_SBCustomize/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb01f/NS_sprm::LN_SXaPage/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB01F/NS_sprm::LN_SXaPage/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb020/NS_sprm::LN_SYaPage/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB020/NS_sprm::LN_SYaPage/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb021/NS_sprm::LN_SDxaLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB021/NS_sprm::LN_SDxaLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb022/NS_sprm::LN_SDxaRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB022/NS_sprm::LN_SDxaRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9023/NS_sprm::LN_SDyaTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9023/NS_sprm::LN_SDyaTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9024/NS_sprm::LN_SDyaBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9024/NS_sprm::LN_SDyaBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xb025/NS_sprm::LN_SDzaGutter/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xB025/NS_sprm::LN_SDzaGutter/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5026/NS_sprm::LN_SDmPaperReq/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5026/NS_sprm::LN_SDmPaperReq/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd227/NS_sprm::LN_SPropRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD227/NS_sprm::LN_SPropRMark/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3228/NS_sprm::LN_SFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3228/NS_sprm::LN_SFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3229/NS_sprm::LN_SFFacingCol/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3229/NS_sprm::LN_SFFacingCol/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x322a/NS_sprm::LN_SFRTLGutter/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x322A/NS_sprm::LN_SFRTLGutter/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702b/NS_sprm::LN_SBrcTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702B/NS_sprm::LN_SBrcTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702c/NS_sprm::LN_SBrcLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702C/NS_sprm::LN_SBrcLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702d/NS_sprm::LN_SBrcBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702D/NS_sprm::LN_SBrcBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702e/NS_sprm::LN_SBrcRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x702E/NS_sprm::LN_SBrcRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x522f/NS_sprm::LN_SPgbProp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x522F/NS_sprm::LN_SPgbProp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7030/NS_sprm::LN_SDxtCharSpace/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7030/NS_sprm::LN_SDxtCharSpace/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9031/NS_sprm::LN_SDyaLinePitch/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9031/NS_sprm::LN_SDyaLinePitch/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5032/NS_sprm::LN_SClm/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5032/NS_sprm::LN_SClm/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5033/NS_sprm::LN_STextFlow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5033/NS_sprm::LN_STextFlow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5400/NS_sprm::LN_TJc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5400/NS_sprm::LN_TJc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9601/NS_sprm::LN_TDxaLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9601/NS_sprm::LN_TDxaLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9602/NS_sprm::LN_TDxaGapHalf/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9602/NS_sprm::LN_TDxaGapHalf/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3403/NS_sprm::LN_TFCantSplit/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3403/NS_sprm::LN_TFCantSplit/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3404/NS_sprm::LN_TTableHeader/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x3404/NS_sprm::LN_TTableHeader/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd605/NS_sprm::LN_TTableBorders/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD605/NS_sprm::LN_TTableBorders/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd606/NS_sprm::LN_TDefTable10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD606/NS_sprm::LN_TDefTable10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9407/NS_sprm::LN_TDyaRowHeight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x9407/NS_sprm::LN_TDyaRowHeight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd608/NS_sprm::LN_TDefTable/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD608/NS_sprm::LN_TDefTable/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd609/NS_sprm::LN_TDefTableShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD609/NS_sprm::LN_TDefTableShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd612/NS_sprm::LN_TCellShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD612/NS_sprm::LN_TCellShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x740a/NS_sprm::LN_TTlp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x740A/NS_sprm::LN_TTlp/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x560b/NS_sprm::LN_TFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x560B/NS_sprm::LN_TFBiDi/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x740c/NS_sprm::LN_THTMLProps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x740C/NS_sprm::LN_THTMLProps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd620/NS_sprm::LN_TSetBrc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD620/NS_sprm::LN_TSetBrc/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7621/NS_sprm::LN_TInsert/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7621/NS_sprm::LN_TInsert/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5622/NS_sprm::LN_TDelete/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5622/NS_sprm::LN_TDelete/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7623/NS_sprm::LN_TDxaCol/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7623/NS_sprm::LN_TDxaCol/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5624/NS_sprm::LN_TMerge/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5624/NS_sprm::LN_TMerge/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5625/NS_sprm::LN_TSplit/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x5625/NS_sprm::LN_TSplit/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd626/NS_sprm::LN_TSetBrc10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD626/NS_sprm::LN_TSetBrc10/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7627/NS_sprm::LN_TSetShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7627/NS_sprm::LN_TSetShd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7628/NS_sprm::LN_TSetShdOdd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7628/NS_sprm::LN_TSetShdOdd/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7629/NS_sprm::LN_TTextFlow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x7629/NS_sprm::LN_TTextFlow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd62a/NS_sprm::LN_TDiagLine/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD62A/NS_sprm::LN_TDiagLine/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd62b/NS_sprm::LN_TVertMerge/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD62B/NS_sprm::LN_TVertMerge/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd62c/NS_sprm::LN_TVertAlign/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD62C/NS_sprm::LN_TVertAlign/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd61a/NS_sprm::LN_TCellTopColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD61A/NS_sprm::LN_TCellTopColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd61b/NS_sprm::LN_TCellLeftColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD61B/NS_sprm::LN_TCellLeftColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd61c/NS_sprm::LN_TCellBottomColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD61C/NS_sprm::LN_TCellBottomColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd61d/NS_sprm::LN_TCellRightColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD61D/NS_sprm::LN_TCellRightColor/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd613/NS_sprm::LN_TGridLineProps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD613/NS_sprm::LN_TGridLineProps/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6816/NS_sprm::LN_CIndrsid/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6816/NS_sprm::LN_CIndrsid/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6817/NS_sprm::LN_Cdelrsid/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6817/NS_sprm::LN_Cdelrsid/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6649/NS_sprm::LN_PTableDepth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6649/NS_sprm::LN_PTableDepth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xd670/NS_sprm::LN_TCellShadow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xD670/NS_sprm::LN_TCellShadow/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6424/NS_sprm::LN_PBrcTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6424/NS_sprm::LN_PBrcTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6425/NS_sprm::LN_PBrcLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6425/NS_sprm::LN_PBrcLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6426/NS_sprm::LN_PBrcBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6426/NS_sprm::LN_PBrcBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6427/NS_sprm::LN_PBrcRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6427/NS_sprm::LN_PBrcRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6428/NS_sprm::LN_PBrcBetween/g" < $1 > $1.out && mv $1.out $1 +sed "s/0x6428/NS_sprm::LN_PBrcBetween/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc64e/NS_sprm::LN_PBorderTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC64E/NS_sprm::LN_PBorderTop/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc64f/NS_sprm::LN_PBorderLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC64F/NS_sprm::LN_PBorderLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc650/NS_sprm::LN_PBorderBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC650/NS_sprm::LN_PBorderBottom/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc651/NS_sprm::LN_PBorderRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC651/NS_sprm::LN_PBorderRight/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xc652/NS_sprm::LN_PBorderBetween/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xC652/NS_sprm::LN_PBorderBetween/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca72/NS_sprm::LN_CBorder/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA72/NS_sprm::LN_CBorder/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xf614/NS_sprm::LN_TTPreferredWidth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xF614/NS_sprm::LN_TTPreferredWidth/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xf661/NS_sprm::LN_TTRLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xF661/NS_sprm::LN_TTRLeft/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xca78/NS_sprm::LN_CEastAsianLayout/g" < $1 > $1.out && mv $1.out $1 +sed "s/0xCA78/NS_sprm::LN_CEastAsianLayout/g" < $1 > $1.out && mv $1.out $1 diff --git a/writerfilter/source/doctok/resourceidmapper.xsl b/writerfilter/source/doctok/resourceidmapper.xsl new file mode 100644 index 000000000000..83892770685a --- /dev/null +++ b/writerfilter/source/doctok/resourceidmapper.xsl @@ -0,0 +1,125 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> + <xsl:output method="text" /> + + <!-- Key all attributes with the same name and same value --> + <xsl:key name="same-valued-tagged-data" + match="UML:TaggedValue.dataValue" use="." /> + + <xsl:template match="/"> + <out> + <xsl:text> +/* + + THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT! + +*/ + +package analyze; + +import java.util.LinkedHashMap; + +/** + * + * @author hb137859 + */ +public class ResourceIdMap extends LinkedHashMap <String, Integer > { + + static ResourceIdMap mInstance = new ResourceIdMap(); + + /** Creates a new instance of ResourceIdMap */ + protected ResourceIdMap() { +/* Attributes */
</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"][count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <!-- <xsl:when test='.//UML:TaggedValue.dataValue = preceding::*//UML:TaggedValue.dataValue'/>--> + <xsl:otherwise> + <xsl:text>put("</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>", </xsl:text> + <xsl:value-of select='10000 + position()'/> + <xsl:text>);
</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + +/* Operations */
</xsl:text> + <xsl:for-each select='.//UML:Operation[@name!="reserved"][count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text>put("</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>", </xsl:text> + <xsl:value-of select='20000 + position()'/> + <xsl:text>); 
</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + +/* Classes */
</xsl:text> + <xsl:for-each select='.//UML:Class[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="classid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noqname"]'/> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text>put("</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>", </xsl:text> + <xsl:value-of select='30000 + position()'/> + <xsl:text>); 
</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + } + + static ResourceIdMap instance() { + return mInstance; + } +}; +</xsl:text> +</out> +</xsl:template> + + <xsl:template name='idtoqname'> + <xsl:param name='id'/>rtf:<xsl:value-of select='substring-after($id, ":")'/> + </xsl:template> + +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/resourceidmapperback.xsl b/writerfilter/source/doctok/resourceidmapperback.xsl new file mode 100644 index 000000000000..8f00e76d7dc1 --- /dev/null +++ b/writerfilter/source/doctok/resourceidmapperback.xsl @@ -0,0 +1,125 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> + <xsl:output method="text" /> + + <!-- Key all attributes with the same name and same value --> + <xsl:key name="same-valued-tagged-data" + match="UML:TaggedValue.dataValue" use="." /> + + <xsl:template match="/"> + <out> + <xsl:text> +/* + + THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT! + +*/ + +package analyze; + +import java.util.LinkedHashMap; + +/** + * + * @author hb137859 + */ +public class ResourceIdMapBackwards extends LinkedHashMap <Integer, String > { + + static ResourceIdMapBackwards mInstance = new ResourceIdMapBackwards(); + + /** Creates a new instance of ResourceIdMapBackwards */ + protected ResourceIdMapBackwards() { +/* Attributes */
</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"][count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <!-- <xsl:when test='.//UML:TaggedValue.dataValue = preceding::*//UML:TaggedValue.dataValue'/>--> + <xsl:otherwise> + <xsl:text>put(</xsl:text> + <xsl:value-of select='10000 + position()'/> + <xsl:text>, "</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>");
</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + +/* Operations */
</xsl:text> + <xsl:for-each select='.//UML:Operation[@name!="reserved"][count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text>put(</xsl:text> + <xsl:value-of select='20000 + position()'/> + <xsl:text>, "</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>"); 
</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + +/* Classes */
</xsl:text> + <xsl:for-each select='.//UML:Class[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="classid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noqname"]'/> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text>put(</xsl:text> + <xsl:value-of select='30000 + position()'/> + <xsl:text>, "</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>"); 
</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + } + + static ResourceIdMapBackwards instance() { + return mInstance; + } +}; +</xsl:text> +</out> +</xsl:template> + + <xsl:template name='idtoqname'> + <xsl:param name='id'/>rtf:<xsl:value-of select='substring-after($id, ":")'/> + </xsl:template> + +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/resourceids.xsl b/writerfilter/source/doctok/resourceids.xsl new file mode 100644 index 000000000000..fb9895c1c1c6 --- /dev/null +++ b/writerfilter/source/doctok/resourceids.xsl @@ -0,0 +1,205 @@ +<!-- +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> + <xsl:output method="text" /> + + <!-- Key all attributes with the same name and same value --> + <xsl:key name="same-valued-tagged-data" + match="UML:TaggedValue.dataValue" use="." /> + + <xsl:template match="/"> + <out> + <xsl:text> +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * http://www.openoffice.org/license.html + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +/* + + THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT! + +*/ +#ifndef INCLUDED_RESOURCESIDS +#define INCLUDED_RESOURCESIDS + +#include <sal/types.h> +#include <resourcemodel/WW8ResourceModel.hxx> + +namespace writerfilter { + +namespace NS_rtf { + +/* Attributes */</xsl:text> +<xsl:for-each select='.//UML:Attribute[@name!="reserved"][count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0]'> + <xsl:variable name="pos" select="position()"/> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <!-- <xsl:when test='.//UML:TaggedValue.dataValue = preceding::*//UML:TaggedValue.dataValue'/>--> + <xsl:otherwise> + <xsl:text> +const Id </xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text> = </xsl:text> + <xsl:variable name="id" select="10000 + $pos"/> + <xsl:value-of select='$id'/> + <xsl:text>; // 0x</xsl:text> + <xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="$id"/> + </xsl:call-template> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> +</xsl:for-each> +<xsl:text> + +/* Operations */</xsl:text> +<xsl:for-each select='.//UML:Operation[@name!="reserved"][count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0]'> + <xsl:variable name="pos" select="position()"/> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text> +const Id </xsl:text> +<xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> +</xsl:call-template> +<xsl:text> = </xsl:text> +<xsl:variable name="id" select="20000 + $pos"/> +<xsl:value-of select='$id'/> +<xsl:text>; // 0x</xsl:text> +<xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="$id"/> +</xsl:call-template> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> +</xsl:for-each> +<xsl:text> + +/* Classes */</xsl:text> +<xsl:for-each select='.//UML:Class[@name!="reserved"]'> + <xsl:variable name="pos" select="position()"/> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="classid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noqname"]'/> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text> +const Id </xsl:text> +<xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> +</xsl:call-template> +<xsl:text> = </xsl:text> +<xsl:value-of select='30000 + $pos'/> +<xsl:text>; // 0x</xsl:text> +<xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="30000 + position()"/> +</xsl:call-template> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> +</xsl:for-each> +<xsl:text> +} + +namespace NS_dff +{</xsl:text> +<xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="dffopt"]'> + <xsl:variable name ="optname"> + <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="optname"]/UML:TaggedValue.dataValue'/> + </xsl:variable> + <xsl:variable name="fopid"> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="fopid"]'> + <xsl:value-of select='UML:TaggedValue.dataValue'/> + </xsl:for-each> + </xsl:variable> + <xsl:text> +const Id </xsl:text> + <xsl:call-template name="idtoqname"> + <xsl:with-param name="id"><xsl:value-of select="$optname"/></xsl:with-param> + </xsl:call-template> + <xsl:text> = </xsl:text> + <xsl:value-of select="$fopid"/> + <xsl:text>; // 0x</xsl:text> + <xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="$fopid"/> + </xsl:call-template> +</xsl:for-each> +<xsl:text> +} + + +} + +#endif // INCLUDED_RESOURCESIDS
</xsl:text></out> +</xsl:template> + +<xsl:template name='idtoqname'> + <xsl:param name='id'/>LN_<xsl:value-of select='substring-after($id, ":")'/> +</xsl:template> + +<xsl:template name='dectohex'> + <xsl:param name="number"/> + <xsl:if test="$number > 16"> + <xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="floor($number div 16)"/> + </xsl:call-template> + </xsl:if> + <xsl:value-of select="substring('0123456789abcdef', $number mod 16 + 1, 1)"/> +</xsl:template> + +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/resources.xmi b/writerfilter/source/doctok/resources.xmi new file mode 100644 index 000000000000..926e046d37b9 --- /dev/null +++ b/writerfilter/source/doctok/resources.xmi @@ -0,0 +1,63712 @@ +<?xml version="1.0"?> +<XMI xmlns:UML="org.omg.xmi.namespace.UML" xmi.version="1.2"> + <XMI.header> + <XMI.documentation/> + </XMI.header> + <XMI.content> + <UML:Model name="WW8Document"> + <UML:Namespace.ownedElement> + <!--Stereotypes --> + <UML:Stereotype xmi.id="access" name="access"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="plcf" name="plcf"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="withindex" name="withindex"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="withmembers" name="withmembers"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="resolvenoauto" name="resolvenoauto"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="initimpl" name="initimpl"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="resource" name="resource"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="ww8resource" name="ww8resource"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="ww8sprm" name="ww8sprm"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="ww8sprmbinary" name="ww8sprmbinary"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="debug" name="debug"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="reference" name="reference"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="attribute" name="attribute"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="attributeremainder" name="attribute"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="noresolve" name="noresolve"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="noqname" name="noqname"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="array" name="array"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="string" name="string"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="binary" name="binary"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="dffrecord" name="dffrecord"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="dffopt" name="dffopt"> + <UML:Stereotype.baseClass>Class</UML:Stereotype.baseClass> + </UML:Stereotype> + <UML:Stereotype xmi.id="virtual" name="virtual"> + <UML:Stereotype.baseClass>Attribute</UML:Stereotype.baseClass> + </UML:Stereotype> + <!--Stereotypes--> + <!--Datatypes --> + <UML:DataType xmi.id="U8" name="U8"/> + <UML:DataType xmi.id="U16" name="U16"/> + <UML:DataType xmi.id="U32" name="U32"/> + <UML:DataType xmi.id="String" name="String"/> + <UML:DataType xmi.id="Value" name="Value"/> + <UML:DataType xmi.id="Sprm" name="Sprm"/> + <!--Datatypes--> + <!--Tag definitions --> + <UML:TagDefinition tagType="String" xmi.id="comment" name="comment"/> + <UML:TagDefinition tagType="String" xmi.id="offset" name="offset"/> + <UML:TagDefinition tagType="String" xmi.id="shift" name="shift"/> + <UML:TagDefinition tagType="String" xmi.id="mask" name="mask"/> + <UML:TagDefinition tagType="String" xmi.id="arraycount" name="arraycount"/> + <UML:TagDefinition tagType="String" xmi.id="bits" name="bits"/> + <UML:TagDefinition tagType="String" xmi.id="attrid" name="attrid"/> + <UML:TagDefinition tagType="String" xmi.id="opid" name="opid"/> + <UML:TagDefinition tagType="String" xmi.id="classid" name="opid"/> + <UML:TagDefinition tagType="String" xmi.id="size" name="size"/> + <UML:TagDefinition tagType="String" xmi.id="sprmcode" name="sprmcode"/> + <UML:TagDefinition tagType="String" xmi.id="sprmid" name="sprmid"/> + <UML:TagDefinition tagType="String" xmi.id="dffid" name="dffid"/> + <!--Tag definitions --> + <!--Classes without stereotype--> + <!--Class Blob--> + <UML:Class xmi.id="Blob" name="Blob"/> + <UML:Generalization isSpecification="false" xmi.id="Blob-BinaryObj"> + <UML:Generalization.child> + <UML:Class xmi.idref="Blob"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="BinaryObj"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class Blob--> + <!--Class TextboxText--> + <UML:Class xmi.id="TextboxText" name="TextboxText"/> + <UML:Generalization isSpecification="false" xmi.id="TextboxText-Stream"> + <UML:Generalization.child> + <UML:Class xmi.idref="TextboxText"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Stream"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class TextboxText--> + <!--Class UPX--> + <UML:Class xmi.id="UPX" name="UPX"/> + <UML:Generalization isSpecification="false" xmi.id="UPX-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="UPX"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class UPX--> + <!--Class SEPX--> + <UML:Class xmi.id="SEPX" name="SEPX"/> + <UML:Generalization isSpecification="false" xmi.id="SEPX-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="SEPX"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class SEPX--> + <!--Class DffRecord--> + <UML:Class xmi.id="DffRecord" name="DffRecord"/> + <UML:Generalization isSpecification="false" xmi.id="DffRecord-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="DffRecord"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class DffRecord--> + <!--Class Papx--> + <UML:Class xmi.id="Papx" name="Papx"> + <UML:Classifier.feature> + <UML:Attribute name="istd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ISTD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <!--Class Papx--> + <!--Class dummy--> + <UML:Class xmi.id="dummy" name="dummy"> + <UML:Classifier.feature> + <UML:Attribute name="header"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:header</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="footer"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:footer</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="headerr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:headerr</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="headerl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:headerl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="footerr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:footerr</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="footerl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:footerl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="headerf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:headerf</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="footerf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:footerf</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="footnote"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:footnote</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="endnote"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:endnote</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="annotation"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:annotation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="bookmarkname"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BOOKMARKNAME</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="XAlign"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XAlign</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="YAlign"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:YAlign</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="XRelTo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XRelTo</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="YRelTo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:YRelTo</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="LayoutInTableCell"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LayoutInTableCell</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="Inline"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:Inline</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dffrecord"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DffRecord</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dffattribute"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DffAttribute</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dfftype"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dfftype</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dffheader"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dffheader</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="instance"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dffinstance</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dffversion"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dffversion</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="blob"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:blob</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="SttbAssoc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SttbAssoc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <!--Class dummy--> + <!--Classes without stereotype--> + <!--Resources--> + <UML:Class xmi.id="Properties" name="Properties"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resource"/> + </UML:ModelElement.stereotype> + </UML:Class> + <UML:Class xmi.id="Table" name="Table"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resource"/> + </UML:ModelElement.stereotype> + </UML:Class> + <UML:Class xmi.id="Stream" name="Stream"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resource"/> + </UML:ModelElement.stereotype> + </UML:Class> + <UML:Class xmi.id="BinaryObj" name="BinaryObj"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resource"/> + </UML:ModelElement.stereotype> + </UML:Class> + <!--Resources--> + <!--WW8 resources--> + <!--Class DopBase--> + <UML:Class xmi.id="DopBase" name="DopBase"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>84</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fFacingPages"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>31</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fFacingPages</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused1"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>30</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fPMHMainDoc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>29</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fPMHMainDoc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused2"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>27</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x18000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fpc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>25</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fpc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused3"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused4"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xff0000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="rncFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:rncFtn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3fff</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:nFtn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused5"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>31</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>30</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused7"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>29</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused8"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>28</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused9"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>27</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused10"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>26</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fSplAllDone"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>25</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fSplAllDone</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fSplAllClean"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fSplAllClean</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fSplHideErrors"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>23</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x800000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fSplHideErrors</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fGramHideErrors"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>22</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x400000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fGramHideErrors</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLabelDoc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>21</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x200000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fLabelDoc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fHyphCapitals"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fHyphCapitals</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fAutoHyphen"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>19</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fAutoHyphen</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fFormNoFields"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>18</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fFormNoFields</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLinkStyles"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>17</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fLinkStyles</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fRevMarking"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fRevMarking</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused11"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused11</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fExactCWords"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fExactCWords</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fPagHidden"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fPagHidden</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fPagResults"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fPagResults</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLockAtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>11</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x800</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fLockAtn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fMirrorMargins"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fMirrorMargins</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fWord97Compat"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x200</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fWord97Compat</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused12"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused13"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fProtEnabled"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fProtEnabled</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fDispFormFldSel"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fDispFormFldSel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fRMView"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fRMView</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fRMPrint"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fRMPrint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLockVbaProj"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fLockVbaProj</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLockRev"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fLockRev</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fEmbedFonts"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fEmbedFonts</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="copts60"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:copts60</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaTab"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dxaTab</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpgWebOpt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cpgWebOpt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaHotZ"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dxaHotZ</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cConsecHypLim"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cConsecHypLim</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wSpare2"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>18</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:wSpare2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dttmCreated"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dttmCreated</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dttmRevised"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dttmRevised</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dttmLastPrint"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>28</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dttmLastPrint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nRevision"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:nRevision</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="tmEdited"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>34</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:tmEdited</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cWords"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>38</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cWords</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cCh"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>42</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cCh</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cPg"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>46</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cPg</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cParas"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>48</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cParas</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="rncEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>30</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc0000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:rncEdn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3fff0000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="epc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused14"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3c00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused15"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3c0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fPrintFormData"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fPrintFormData</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fSaveFormData"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fSaveFormData</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fShadeFormData"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fShadeFormData</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fShadeMergeFields"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fShadeMergeFields</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="reserved2"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:reserved2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fIncludeSubdocsInStats"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>52</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fIncludeSubdocsInStats</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cLines"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>56</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cLines</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cWordsWithSubdocs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>60</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cWordsWithSubdocs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cChWithSubdocs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>64</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cChWithSubdocs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cPgWithSubdocs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>68</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cPgWithSubdocs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cParasWithSubdocs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>70</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cParasWithSubdocs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cLinesWithSubdocs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>74</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cLinesWithSubdocs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lKeyProtDoc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>78</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lKeyProtDoc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wvkoSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>82</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xe000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:wvkoSaved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pctWwdSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>82</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1ff0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:pctWwdSaved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="zkSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>82</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:zkSaved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused16"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>82</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="iGutterPos"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>82</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:iGutterPos</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="DopBase-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="DopBase"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class DopBase--> + <!--Class ListLevel--> + <UML:Class xmi.id="ListLevel" name="ListLevel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>28</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="iStartAt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ISTARTAT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nfc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:NFC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="jc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:JC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLegel"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FLEGAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fNoRestart"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FNORESTART</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fIdentSav"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FIDENTSAV</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fConverted"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCONVERTED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fTentative"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FTENTATIVE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="rgbxchNums"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:RGBXCHNUMS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ixchFollow"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:IXCHFOLLOW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaSpace"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DXASPACE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaIndent"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DXAINDENT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cbGrpprlChpx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CBGRPPRLCHPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cbGrpprlPapx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>25</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CBGRPPRLPAPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ilvlRestartLim"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>26</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ilvlRestartLim</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="grfhic"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>27</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:grfhic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="xst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:xst</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="ListLevel-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="ListLevel"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class ListLevel--> + <!--Class List--> + <UML:Class xmi.id="List" name="List"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="withindex"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>28</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="listlevel"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LISTLEVEL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="ListLevel"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lsid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LSID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="tplc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:TPLC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fBuildIn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>31</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fBuildIn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ilgpdM1"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7fff0000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ilgpdM1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xffff</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="random"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7fffffff</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>31</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:random</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="rgistd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:RGISTD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fSimpleList"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FSIMPLELIST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fAutoNum"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fAutoNum</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fHybrid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fHybrid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="reserved1"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:reserved1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="grfhic"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>27</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:grfhic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="List-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="List"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class List--> + <!--Class ListTable--> + <UML:Class xmi.id="ListTable" name="ListTable"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="plcf"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nopayloadoffset"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LISTTABLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="classid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="ListTable-Table"> + <UML:Generalization.child> + <UML:Class xmi.idref="ListTable"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Table"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class ListTable--> + <!--Class LFOLevel--> + <UML:Class xmi.id="LFOLevel" name="LFOLevel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="iStartAt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>start-at value if fFormatting == false and fStartAt == true. + (if fFormatting == true, the start-at is stored in the LVL)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ISTARTAT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ilvl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the level to be overridden</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ILVL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fStartAt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>true if the start-at value is overridden</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FSTARTAT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fFormatting"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>true if the formatting is overriden (in which case the LFOLVL + should contain a pointer to a LVL)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FFORMATTING</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unsigned4_6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNSIGNED4_6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="reserved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:RESERVED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="LFOLevel-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="LFOLevel"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class LFOLevel--> + <!--Class LFO--> + <UML:Class xmi.id="LFO" name="LFO"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="withindex"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="lsid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lsid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="clfolvl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:clfolvl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ibstFltAutoNum"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ibstFltAutoNum</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="grfhic"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:grfhic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="LFOData"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LFOData</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="LFOData"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="LFO-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="LFO"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class LFO--> + <!--Class SttbRgtplc--> + <UML:Class xmi.id="SttbRgtplc" name="SttbRgtplc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SttbRgtplc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="classid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="SttbRgtplc-Table"> + <UML:Generalization.child> + <UML:Class xmi.idref="SttbRgtplc"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Table"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class SttbRgtplc--> + <!--Class LFOData--> + <UML:Class xmi.id="LFOData" name="LFOData"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="cp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="LFOData-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="LFOData"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class LFOData--> + <!--Class LFOTable--> + <UML:Class xmi.id="LFOTable" name="LFOTable"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="plcf"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nopayloadoffset"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LFOTABLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="classid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="LFOTable-Table"> + <UML:Generalization.child> + <UML:Class xmi.idref="LFOTable"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Table"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class LFOTable--> + <!--Class FontTable--> + <UML:Class xmi.id="FontTable" name="FontTable"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nopayloadoffset"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="plcf"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FONTTABLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="classid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FontTable-Table"> + <UML:Generalization.child> + <UML:Class xmi.idref="FontTable"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Table"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FontTable--> + <!--Class Font--> + <UML:Class xmi.id="Font" name="Font"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="withindex"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>40</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="f"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="altName"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ALTFONTNAME</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="xszFfn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XSZFFN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>zero terminated string that records name of font. Possibly + followed by a second xsz which records the name of an alternate + font to use if the first named font does not exist on this system. + Maximal size of xszFfn is 65 characters.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Attribute name="cbFfnM1"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>total length of FFN - 1.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CBFFNM1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="prq"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>pitch request</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>03</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PRQ</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fTrueType"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, font is a TrueType font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>04</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FTRUETYPE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused1_3"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>08</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED1_3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ff"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>font family id</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>70</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused1_7"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>80</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED1_7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wWeight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>base weight of font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WWEIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="chs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character set identifier</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CHS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ixchSzAlt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>index into ffn.szFfn to the name of the alternate font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:IXCHSZALT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="panose"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>? This is supposed to be of type PANOSE.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PANOSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>? This is supposed to be of type FONTSIGNATURE.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="Font-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="Font"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class Font--> + <!--Class Style--> + <UML:Class xmi.id="Style" name="Style"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="withindex"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="sti"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>invariant style identifier</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0FFF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:STI</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fScratch"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>spare field for any temporary use, always reset back to + zero!</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FSCRATCH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fInvalHeight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>PHEs of all text with this style are wrong</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FINVALHEIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fHasUpe"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>UPEs have been generated</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FHASUPE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fMassCopy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>std has been mass-copied; if unused at save time, style should + be deleted</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FMASSCOPY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="sgc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>style type code</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>000F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SGC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="istdBase"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>base style</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FFF0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ISTDBASE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cupx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue># of UPXs (and UPEs)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>000F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CUPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="istdNext"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>next style</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FFF0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ISTDNEXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="bchUpe"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset to end of upx's, start of upe's</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BCHUPE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fAutoRedef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>auto redefine style when appropriate</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xa</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0001</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FAUTOREDEF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fHidden"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>hidden from UI?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xa</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0002</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FHIDDEN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused8_3"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unused bits</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xa</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FFFC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED8_3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="xstzName"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XSTZNAME</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="xstzName1"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XSTZNAME1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="upxstart"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UPXSTART</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="noresolve"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="upx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="UPX"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="Style-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="Style"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class Style--> + <!--Class StyleSheet--> + <UML:Class xmi.id="StyleSheet" name="StyleSheet"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="plcf"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nopayloadoffset"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:Attribute name="size"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Size of style sheet info</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CSTD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + <UML:Attribute name="cstd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Count of styles in stylesheet</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CSTD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cbSTDBaseInFile"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Length of STD Base as stored in a file</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CBSTDBASEINFILE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fStdStylenamesWritten"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Are built-in stylenames stored?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0001</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FSTDSTYLENAMESWRITTEN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused4_2"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Spare flags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FFFE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED4_2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="stiMaxWhenSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Max sti known when this file was written</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:STIMAXWHENSAVED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="istdMaxFixedWhenSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How many fixed-index istds are there?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ISTDMAXFIXEDWHENSAVED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nVerBuiltInNamesWhenSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Current version of built-in stylenames</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:NVERBUILTINNAMESWHENSAVED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="rgftcStandardChpStsh"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>ftc used by StandardChpStsh for this document</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:RGFTCSTANDARDCHPSTSH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:STYLESHEET</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="classid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="StyleSheet-Table"> + <UML:Generalization.child> + <UML:Class xmi.idref="StyleSheet"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Table"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class StyleSheet--> + <!--Class Fib--> + <UML:Class xmi.id="Fib" name="Fib"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="withmembers"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>898</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="wIdent"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>(fibh) FIBH Beginning of the FIB header magic number</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WIDENT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nFib"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FIB version written. This will be >= 101 for all Word 6.0 + for Windows and after documents.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0002</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:NFIB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nProduct"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>product version written by</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0004</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:NPRODUCT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>language stamp -- localized version + In pre-WinWord 2.0 files this value was the nLocale. If value is + < 999, then it is the nLocale, otherwise it is the lid.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0006</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnNext"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0008</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNNEXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fDot"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Set if this document is a template</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0001</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FDOT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fGlsy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Set if this document is a glossary</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0002</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FGLSY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fComplex"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, file is in complex, fast-saved format.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0004</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCOMPLEX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fHasPic"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set if file contains 1 or more pictures</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0008</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FHASPIC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cQuickSaves"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of times file was quicksaved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>00F0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CQUICKSAVES</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fEncrypted"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Set if file is encrypted</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0100</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FENCRYPTED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fWhichTblStm"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>When 0, this fib refers to the table stream named "0Table", + when 1, this fib refers to the table stream named "1Table". + Normally, a file will have only one table stream, but under unusual + circumstances a file may have table streams with both names. In + that case, this flag must be used to decide which table stream is + valid.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0200</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FWHICHTBLSTM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fReadOnlyRecommended"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Set when user has recommended that file be read read-only</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FREADONLYRECOMMENDED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fWriteReservation"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Set when file owner has made the file write reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>11</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0800</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FWRITERESERVATION</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fExtChar"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Set when using extended character set in file</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FEXTCHAR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLoadOverride"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>REVIEW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FLOADOVERRIDE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fFarEast"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>REVIEW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FFAREAST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fCrypto"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>REVIEW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCRYPTO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="nFibBack"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>This file format it compatible with readers that understand + nFib at or above this value.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:NFIBBACK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lKey"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>File encrypted key, only valid if fEncrypted.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x000E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LKEY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="envr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>environment in which file was created + 0 created by Win Word + 1 created by Mac Word</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0012</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ENVR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fMac"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, this file was last saved in the Mac environment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>01</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FMAC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fEmptySpecial"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>02</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FEMPTYSPECIAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fLoadOverridePage"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>04</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FLOADOVERRIDEPAGE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fFutureSavedUndo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>08</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FFUTURESAVEDUNDO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fWord97Saved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FWORD97SAVED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fSpare0"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FSPARE0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="chs"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Default extended character set id for text in document stream. + (overridden by chp.chse) + 0 by default characters in doc stream should be interpreted using + the ANSI character set used by Windows + 256 characters in doc stream should be interpreted using the + Macintosh character set.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0014</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CHS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="chsTables"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Default extended character set id for text in internal data + structures + 0 by default characters stored in internal data structures should + be interpreted using the ANSI character set used by Windows + 256 characters stored in internal data structures should be + interpreted using the Macintosh character set.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0016</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CHSTABLES</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcMin"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>file offset of first character of text. In non-complex + files a CP can be transformed into an FC by the + following transformation: + fc = cp + fib.fcMin.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0018</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCMIN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcMac"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>file offset of last character of text in document text stream + + 1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x001C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCMAC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="csw"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Count of fields in the array of "shorts"</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0020</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CSW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wMagicCreated"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>[Beginning of the array of shorts, rgls] + Unique number Identifying the File's creator 6A62 is the creator ID + for Word and is reserved. Other creators should choose a different + value.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0022</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WMAGICCREATED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wMagicRevised"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>identifies the File's last modifier</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0024</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WMAGICREVISED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wMagicCreatedPrivate"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>private data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0026</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WMAGICCREATEDPRIVATE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wMagicRevisedPrivate"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>private data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0028</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WMAGICREVISEDPRIVATE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnFbpChpFirst_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x002A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNFBPCHPFIRST_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnChpFirst_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x002C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNCHPFIRST_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpnBteChp_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x002E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPNBTECHP_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnFbpPapFirst_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0030</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNFBPPAPFIRST_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnPapFirst_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0032</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNPAPFIRST_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpnBtePap_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0034</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPNBTEPAP_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnFbpLvcFirst_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0036</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNFBPLVCFIRST_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnLvcFirst_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0038</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNLVCFIRST_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpnBteLvc_W6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x003A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPNBTELVC_W6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lidFE"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Language id if document was written by Far East version of Word + (i.e. FIB.fFarEast is on)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x003C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LIDFE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="clw"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Number of fields in the array of longs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x003E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CLW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cbMac"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>[Beginning of the array of longs, rglw] + file offset of last byte written to file + 1.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0040</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CBMAC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lProductCreated"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>contains the build date of the creator. 10695 indicates the + creator program was compiled on Jan 6, 1995</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0044</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LPRODUCTCREATED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lProductRevised"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>contains the build date of the File's last modifier</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0048</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LPRODUCTREVISED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpText"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of main document text stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x004C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPTEXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of footnote subdocument text stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0050</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpHdd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of header subdocument text stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0054</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPHDD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpMcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of macro subdocument text stream, which should now + always be 0.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0058</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpAtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of annotation subdocument text stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x005C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPATN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of endnote subdocument text stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0060</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of textbox subdocument text stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0064</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ccpHdrTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of header textbox subdocument text stream.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0068</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CCPHDRTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnFbpChpFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when there was insufficient memory for Word to expand the + plcfbte at save time, the plcfbte is written to the file in a + linked list of 512-byte pieces starting with this pn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x006C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNFBPCHPFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnChpFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the page number of the lowest numbered page in the document + that records CHPX FKP information</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0070</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNCHPFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpnBteChp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of CHPX FKPs recorded in file. In non-complex files if + the number of entries in the plcfbteChpx is less than this, the + plcfbteChpx is incomplete.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0074</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPNBTECHP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnFbpPapFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when there was insufficient memory for Word to expand the + plcfbte at save time, the plcfbte is written to the file in a + linked list of 512-byte pieces starting with this pn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0078</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNFBPPAPFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnPapFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the page number of the lowest numbered page in the document + that records PAPX FKP information</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x007C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNPAPFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpnBtePap"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of PAPX FKPs recorded in file. In non-complex files if + the number of entries in the plcfbtePapx is less than this, the + plcfbtePapx is incomplete.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0080</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPNBTEPAP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnFbpLvcFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when there was insufficient memory for Word to expand the + plcfbte at save time, the plcfbte is written to the file in a + linked list of 512-byte pieces starting with this pn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0084</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNFBPLVCFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pnLvcFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the page number of the lowest numbered page in the document + that records LVC FKP information</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0088</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:PNLVCFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cpnBteLvc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of LVC FKPs recorded in file. In non-complex files if the + number of entries in the plcfbtePapx is less than this, the + plcfbtePapx is incomplete.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x008C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPNBTELVC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcIslandFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0090</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCISLANDFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcIslandLim"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0094</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCISLANDLIM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cfclcb"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Number of fields in the array of FC/LCB pairs.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0098</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CFCLCB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcStshfOrig"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>[Beginning of array of FC/LCB pairs, rgfclcb] + file offset of original allocation for STSH in table stream. During + fast save Word will attempt to reuse this allocation if STSH is + small enough to fit.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x009A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTSHFORIG</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbStshfOrig"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of original STSH allocation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x009E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTSHFORIG</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcStshf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset of STSH in table stream.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00A2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTSHF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbStshf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of current STSH allocation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00A6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTSHF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffndRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of footnote reference PLCF of FRD + structures. CPs in PLC are relative to main document text stream + and give location of footnote references.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00AA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFNDREF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffndRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of footnote reference PLC== 0 if no footnotes + defined in document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00AE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFNDREF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffndTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of footnote text PLC. CPs in PLC are + relative to footnote subdocument text stream and give location of + beginnings of footnote text for corresponding references recorded + in plcffndRef. No structure is stored in this plc. There will just + be n+1 FC entries in this PLC when there are n + footnotes</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00B2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFNDTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffndTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of footnote text PLC. == 0 if no footnotes + defined in document</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00B6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFNDTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfandRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of annotation reference ATRD PLC. The + CPs recorded in this PLC give the offset of annotation references + in the main document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00BA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFANDREF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfandRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of annotation reference PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00BE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFANDREF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfandTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of annotation text PLC. The Cps recorded + in this PLC give the offset of the annotation text in the + annotation sub document corresponding to the references stored in + the plcfandRef. There is a 1 to 1 correspondence between entries + recorded in the plcfandTxt and the plcfandRef. No structure is + stored in this PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00C2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFANDTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfandTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of the annotation text PLC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00C6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFANDTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfsed"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of section descriptor SED PLC. CPs in + PLC are relative to main document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00CA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFSED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfsed"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of section descriptor PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00CE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFSED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfpad"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00D2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFPAD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfpad"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00D6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFPAD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfphe"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PHE PLC of paragraph heights. CPs in + PLC are relative to main document text stream. Only written for + files in complex format. Should not be written by third + party creators of Word files.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00DA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFPHE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfphe"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of paragraph height PLC. ==0 when file is + non-complex.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00DE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFPHE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfglsy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of glossary string table. This table + consists of Pascal style strings (strings stored prefixed with a + length byte) concatenated one after another.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00E2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFGLSY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfglsy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of glossary string table. == 0 for non-glossary + documents.!=0 for glossary documents.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00E6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFGLSY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfglsy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of glossary PLC. CPs in PLC are relative + to main document and mark the beginnings of glossary entries and + are in 1-1 correspondence with entries of sttbfglsy. No structure + is stored in this PLC. There will be n+1 FC entries + in this PLC when there are n glossary entries.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00EA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFGLSY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfglsy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of glossary PLC.== 0 for non-glossary + documents.!=0 for glossary documents.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00EE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFGLSY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfhdd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>byte offset in table stream of header HDD PLC. CPs are relative + to header subdocument and mark the beginnings of individual headers + in the header subdocument. No structure is stored in this PLC. + There will be n+1FC entries in this PLC when there are + n headers stored for the document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00F2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFHDD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfhdd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of header PLC. + == 0 if document contains no headers</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00F6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFHDD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfbteChpx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of character property bin table.PLC. FCs + in PLC are file offsets in the main stream. Describes text of main + document and all subdocuments.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00FA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFBTECHPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfbteChpx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of character property bin table PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x00FE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFBTECHPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfbtePapx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of paragraph property bin table.PLC. FCs + in PLC are file offsets in the main stream. Describes text of main + document and all subdocuments.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0102</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFBTEPAPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfbtePapx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of paragraph property bin table PLC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0106</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFBTEPAPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfsea"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PLC reserved for private use. The + SEA is 6 bytes long.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x010A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFSEA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfsea"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of private use PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x010E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFSEA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfffn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of font information STTBF. The sttbfffn + is a STTBF where is string is actually an FFN structure. The + nth entry in the STTBF describes the font that will be + displayed when the chp.ftc for text is equal to n. See the + FFN file structure definition.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0112</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFFFN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfffn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes in sttbfffn.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0116</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFFFN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldMom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to the FLD PLC of field positions in the + main document. The CPs point to the beginning CP of a field, the CP + of field separator character inside a field and the ending CP of + the field. A field may be nested within another field. 20 levels of + field nesting are allowed.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x011A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDMOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldMom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes in plcffldMom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x011E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDMOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to the FLD PLC of field positions in the + header subdocument.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0122</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes in plcffldHdr</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0126</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to the FLD PLC of field positions in the + footnote subdocument.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x012A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes in plcffldFtn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x012E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldAtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to the FLD PLC of field positions in the + annotation subdocument.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0132</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDATN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldAtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes in plcffldAtn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0136</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDATN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldMcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x013A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldMcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x013E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfbkmk"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the STTBF that records bookmark names + in the main document</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0142</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFBKMK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfbkmk"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0146</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFBKMK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfbkf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLCF that records the beginning + CP offsets of bookmarks in the main document. See BKF structure + definition</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x014A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFBKF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfbkf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x014E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFBKF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfbkl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLCF that records the ending CP + offsets of bookmarks recorded in the main document. No structure is + stored in this PLCF.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0152</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFBKL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfbkl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0156</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFBKL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcCmds"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the macro commands. These commands + are private and undocumented.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x015A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCCMDS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbCmds"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undocument size of undocument structure not documented + above</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x015E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBCMDS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcmcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0162</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcmcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0166</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfmcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x016A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfmcr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x016E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFMCR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPrDrvr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the printer driver information (names + of drivers, port, etc.)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0172</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPRDRVR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPrDrvr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of the printer driver information (names of + drivers, port, etc.)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0176</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPRDRVR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPrEnvPort"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the print environment in portrait + mode.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x017A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPRENVPORT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPrEnvPort"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of the print environment in portrait mode.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x017E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPRENVPORT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPrEnvLand"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the print environment in landscape + mode.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0182</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPRENVLAND</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPrEnvLand"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of the print environment in landscape mode.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0186</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPRENVLAND</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcWss"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of Window Save + State data structure. WSS contains dimensions of + document's main text window and the last selection made by Word + user.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x018A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCWSS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbWss"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of WSS. ==0 if unable to store the window state. + Should not be written by third party creators of Word files.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x018E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBWSS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcDop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of document property data + structure.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0192</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCDOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbDop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of document properties.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0196</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBDOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfAssoc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of STTBF of associated strings. The + strings in this table specify document summary info and the paths + to special documents related to this document. See documentation of + the STTBFASSOC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x019A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFASSOC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfAssoc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x019E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFASSOC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcClx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of beginning of information for + complex files. Consists of an encoding of all of the + prms quoted by the document followed by the plcpcd + (piece table) for the document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01A2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCCLX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbClx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of complex file information == 0 if file is + non-complex.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01A6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBCLX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfpgdFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01AA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFPGDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfpgdFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01AE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFPGDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcAutosaveSource"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the name of the original file. + fcAutosaveSource and cbAutosaveSource should both be 0 if autosave + is off.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01B2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCAUTOSAVESOURCE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbAutosaveSource"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of the name of the original file.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01B6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBAUTOSAVESOURCE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcGrpXstAtnOwners"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of group of strings recording the names + of the owners of annotations stored in the document</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01BA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCGRPXSTATNOWNERS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbGrpXstAtnOwners"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of bytes of the group of strings</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01BE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBGRPXSTATNOWNERS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfAtnbkmk"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the sttbf that records names of + bookmarks for the annotation subdocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01C2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFATNBKMK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfAtnbkmk"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of the sttbf that records names of bookmarks + for the annotation subdocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01C6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFATNBKMK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcdoaMom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01CA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCDOAMOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcdoaMom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01CE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCDOAMOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcdoaHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no longer used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01D2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCDOAHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcdoaHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01D6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCDOAHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcspaMom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the FSPA PLC for main + document. == 0 if document has no office art objects.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01DA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCSPAMOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcspaMom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of the FSPA PLC of the main + document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01DE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCSPAMOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcspaHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the FSPA PLC for header + document. == 0 if document has no office art objects.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01E2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCSPAHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcspaHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of the FSPA PLC of the header + document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01E6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCSPAHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfAtnbkf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of BKF (bookmark first) PLC of the + annotation subdocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01EA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFATNBKF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfAtnbkf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of BKF (bookmark first) PLC of the annotation + subdocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01EE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFATNBKF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfAtnbkl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of BKL (bookmark last) PLC of the + annotation subdocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01F2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFATNBKL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfAtnbkl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of PLC marking the CP limits of the annotation + bookmarks. No structure is stored in this PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01F6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFATNBKL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPms"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PMS (Print Merge State) information + block. This contains the current state of a print merge + operation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01FA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPMS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPms"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of PMS. ==0 if no current print merge state. + Should not be written by third party creators of Word files.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x01FE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPMS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcFormFldSttbf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of form field Sttbf which contains + strings used in form field dropdown controls</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0202</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCFORMFLDSTTBF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbFormFldSttbf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of form field Sttbf</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0206</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBFORMFLDSTTBF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfendRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of endnote reference PLCF of FRD + structures. CPs in PLCF are relative to main document text stream + and give location of endnote references.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x020A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFENDREF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfendRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x020E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFENDREF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfendTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PlcfendRef which points to endnote + text in the endnote document stream which corresponds with the + plcfendRef. No structure is stored in this PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0212</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFENDTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfendTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0216</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFENDTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to FLD PLCF of field positions in the + endnote subdoc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x021A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x021E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfpgdEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>not used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0222</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFPGDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfpgdEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0226</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFPGDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcDggInfo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the office art object table data. The + format of office art object table data is found in a separate + document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x022A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCDGGINFO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbDggInfo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length in bytes of the office art object table data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x022E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBDGGINFO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfRMark"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to STTBF that records the author + abbreviations for authors who have made revisions in the + document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0232</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFRMARK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfRMark"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0236</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFRMARK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfCaption"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to STTBF that records caption titles + used in the document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x023A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFCAPTION</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfCaption"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x023E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFCAPTION</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfAutoCaption"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to the STTBF that records the object + names and indices into the caption STTBF for objects which get auto + captions.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0242</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFAUTOCAPTION</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfAutoCaption"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0246</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFAUTOCAPTION</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfwkb"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream to WKB PLCF that describes the + boundaries of contributing documents in a master document</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x024A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFWKB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfwkb"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x024E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFWKB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfspl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PLCF (of SPLS structures) that + records spell check state</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0252</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFSPL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfspl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0256</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFSPL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcftxbxTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PLCF that records the beginning CP in + the text box subdoc of the text of individual text box entries. No + structure is stored in this PLCF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x025A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFTXBXTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcftxbxTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x025E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFTXBXTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the FLD PLCF that records field + boundaries recorded in the textbox subdoc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0262</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0266</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfHdrtxbxTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PLCF that records the beginning CP in + the header text box subdoc of the text of individual header text + box entries. No structure is stored in this PLC.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x026A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFHDRTXBXTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfHdrtxbxTxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x026E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFHDRTXBXTXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcffldHdrTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the FLD PLCF that records field + boundaries recorded in the header textbox subdoc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0272</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFFLDHDRTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcffldHdrTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0276</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFFLDHDRTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcStwUser"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Macro User storage</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x027A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTWUSER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbStwUser"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x027E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTWUSER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbttmbd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of embedded true type font data.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0282</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBTTMBD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbttmbd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0286</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBTTMBD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcUnused"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x028A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCUNUSED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbUnused"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x028E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBUNUSED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPgdMother"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>(FCPGD, beginning of array of fcPgd / fcBkd pairs + rgpgdbkd). + offset in table stream of the PLF that records the page descriptors + for the main text of the doc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0292</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPGDMOTHER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPgdMother"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0296</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPGDMOTHER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcBkdMother"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLCF that records the break + descriptors for the main text of the doc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x029A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCBKDMOTHER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbBkdMother"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x029E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBBKDMOTHER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPgdFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLF that records the page + descriptors for the footnote text of the doc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02A2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPGDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPgdFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02A6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPGDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcBkdFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLCF that records the break + descriptors for the footnote text of the doc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02AA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCBKDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbBkdFtn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02AE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBBKDFTN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPgdEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLF that records the page + descriptors for the endnote text of the doc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02B2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPGDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPgdEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02B6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPGDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcBkdEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the PLCF that records the break + descriptors for the endnote text of the doc.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02BA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCBKDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbBkdEdn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02BE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBBKDEDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfIntlFld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of the STTBF containing field keywords. + This is only used in a small number of the international versions + of word. This field is no longer written to the file for nFib >= + 167.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02C2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFINTLFLD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfIntlFld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Always 0 for nFib >= 167.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02C6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFINTLFLD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcRouteSlip"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of a mailer routing slip.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02CA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCROUTESLIP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbRouteSlip"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02CE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBROUTESLIP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbSavedBy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of STTBF recording the names of the + users who have saved this document alternating with the save + locations.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02D2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBSAVEDBY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbSavedBy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02D6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBSAVEDBY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbFnm"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of STTBF recording filenames of + documents which are referenced by this document.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02DA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFNM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbFnm"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02DE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFNM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfLst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in the table stream of list format information.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02E2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFLST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfLst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02E6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFLST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlfLfo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in the table stream of list format override + information.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02EA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLFLFO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlfLfo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02EE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLFLFO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcftxbxBkd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in the table stream of the textbox break table (a PLCF + of BKDs) for the main document</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02F2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFTXBXBKD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcftxbxBkd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02F6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFTXBXBKD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcftxbxHdrBkd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in the table stream of the textbox break table (a PLCF + of BKDs) for the header subdocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02FA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFTXBXHDRBKD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcftxbxHdrBkd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02FE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFTXBXHDRBKD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcDocUndo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in main stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0302</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCDOCUNDO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbDocUndo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0306</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBDOCUNDO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcRgbuse"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in main stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x030A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCRGBUSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbRgbuse"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x030E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBRGBUSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcUsp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in main stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0312</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCUSP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbUsp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0316</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBUSP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcUskf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x031A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCUSKF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbUskf"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x031E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBUSKF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcupcRgbuse"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0322</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCUPCRGBUSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcupcRgbuse"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0326</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCUPCRGBUSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcupcUsp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x032A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCUPCUSP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcupcUsp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x032E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCUPCUSP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbGlsyStyle"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of string table of style names for + glossary entries</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0332</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBGLSYSTYLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbGlsyStyle"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0336</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBGLSYSTYLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlgosl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of undocumented grammar options PL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x033A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLGOSL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlgosl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x033E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLGOSL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcocx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of undocumented ocx data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0342</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCOCX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcocx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0346</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCOCX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfbteLvc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of character property bin table.PLC. FCs + in PLC are file offsets. Describes text of main document and all + subdocuments.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x034A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFBTELVC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfbteLvc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x034E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFBTELVC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dwLowDateTime"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>(a.k.a FILETIME ftModified)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0352</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DWLOWDATETIME</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dwHighDateTime"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0356</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DWHIGHDATETIME</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcflvc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of LVC PLCF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x035A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFLVC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcflvc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>size of LVC PLCF, ==0 for non-complex files</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x035E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFLVC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcasumy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of autosummary ASUMY PLCF.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0362</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCASUMY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcasumy"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0366</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCASUMY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfgram"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of PLCF (of SPLS structures) which + records grammar check state</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x036A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCPLCFGRAM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfgram"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x036E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBPLCFGRAM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbListNames"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of list names string table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0372</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBLISTNAMES</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbListNames"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0376</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBLISTNAMES</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbfUssr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>offset in table stream of undocumented undo / versioning + data</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x037A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSTTBFUSSR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbfUssr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x037E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCBSTTBFUSSR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="Fib-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="Fib"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class Fib--> + <!--Class FibRgFcLcb2000--> + <UML:Class xmi.id="FibRgFcLcb2000" name="FibRgFcLcb2000"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>856</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfTch"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>744</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPlcfTch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfTch"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>748</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbPlcfTch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcRmdThreading"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>752</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcRmdThreading</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbRmdThreading"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>756</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbRmdThreading</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcMid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>760</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcMid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbMid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>764</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbMid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSttbRgtplc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>768</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcSttbRgtplc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbSttbRgtplc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>772</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbSttbRgtplc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcMsoEnvelope"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>776</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcMsoEnvelope</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="flcbMsoEnvelope"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>780</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:flcbMsoEnvelope</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfLad"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>784</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPlcfLad</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfLad"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>788</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbPlcfLad</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcRgDofr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>792</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcRgDofr</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbRgDofr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>796</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbRgDofr</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcosl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>800</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPlcosl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcosl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>804</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbPlcosl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPlcfCookieOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>808</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPlcfCookieOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPlcfCookieOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>812</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbPlcfCookieOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPgdMotherOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>816</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPgdMotherOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="flcbPgdMotherOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>820</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:flcbPgdMotherOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPgdFtnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>824</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPgdFtnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPgdFtnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>828</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbPgdFtnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcBkdFtnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>832</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcBkdFtnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbBkdFtnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>836</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbBkdFtnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcPgdEdnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>840</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPgdEdnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbPgdEdnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>844</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbPgdEdnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcBkdEdnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>848</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcBkdEdnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lcbBkdEdnOld"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>852</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lcbBkdEdnOld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FibRgFcLcb2000-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FibRgFcLcb2000"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FibRgFcLcb2000--> + <!--Class BKD--> + <UML:Class xmi.id="BKD" name="BKD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="ibkl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>index to BKL entry in plcfbkl that describes the + ending position of this bookmark in the CP stream.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:IBKL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="itcFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when bkf.fCol is 1, this is the index to the first column of a + table column bookmark.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>007F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ITCFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fPub"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, this indicates that this bookmark is marking the range + of a Macintosh Publisher section.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0080</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FPUB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="itcLim"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when bkf.fCol is 1, this is the index to limit column of a + table column bookmark.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7F00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ITCLIM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fCol"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, this bookmark marks a range of columns in a table + specified by [bkf.itcFirst, bkf.itcLim).</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCOL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="BKD-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="BKD"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class BKD--> + <!--Class SED--> + <UML:Class xmi.id="SED" name="SED"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="needsdocument"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>used internally by Word</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcSepx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>file offset in main stream to beginning of SEPX stored for + section. If sed.fcSepx == 0xFFFFFFFF, the section properties for + the section are equal to the standard SEP (see SEP + definition).</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCSEPX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fnMpr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>used internally by Word</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FNMPR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fcMpr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>points to offset in FC space of main stream where the Macintosh + Print Record for a document created on a Mac will be stored</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCMPR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="sepx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sed</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="SEPX"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="SED-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="SED"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class SED--> + <!--Class SHD--> + <UML:Class xmi.id="SHD" name="SHD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="icoFore"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>foreground color (see chp.ico)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>001F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ICOFORE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="icoBack"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>background color (see chp.ico)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>03E0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ICOBACK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ipat"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>shading pattern (see ipat table below) + 0 Automatic + 1 Solid + 2 5 Percent + 3 10 Percent + 4 20 Percent + 5 25 Percent + 6 30 Percent + 7 40 Percent + 8 50 Percent + 9 60 Percent + 10 70 Percent + 11 75 Percent + 12 80 Percent + 13 90 Percent + 14 Dark Horizontal + 15 Dark Vertical + 16 Dark Forward Diagonal + 17 Dark Backward Diagonal + 18 Dark Cross + 19 Dark Diagonal Cross + 20 Horizontal + 21 Vertical + 22 Forward Diagonal + 23 Backward Diagonal + 24 Cross + 25 Diagonal Cross + 35 2.5 Percent + 36 7.5 Percent + 37 12.5 Percent + 38 15 Percent + 39 17.5 Percent + 40 22.5 Percent + 41 27.5 Percent + 42 32.5 Percent + 43 35 Percent + 44 37.5 Percent + 45 42.5 Percent + 46 45 Percent + 47 47.5 Percent + 48 52.5 Percent + 49 55 Percent + 50 57.5 Percent + 51 62.5 Percent + 52 65 Percent + 53 67.5 Percent + 54 72.5 Percent + 55 77.5 Percent + 56 82.5 Percent + 57 85 Percent + 58 87.5 Percent + 59 92.5 Percent + 60 95 Percent + 61 97.5 Percent + 62 97 Percent</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FC00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:IPAT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="SHD-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="SHD"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class SHD--> + <!--Class CellShd--> + <UML:Class xmi.id="CellShd" name="CellShd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="shdForeColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>foreground color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SHDFORECOLOR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shdBackColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>background color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SHDBACKCOLOR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shdPattern"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>pattern</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SHDPATTERN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="cellShd-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="CellShd"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class CellShd--> + <!--Class BRC--> + <UML:Class xmi.id="BRC" name="BRC"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="dptLineWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>width of a single line in 1/8 pt, max of 32 pt.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>00FF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DPTLINEWIDTH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcType"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>border type code: + 0 none + 1 single + 2 thick + 3 double + 5 hairline + 6 dot + 7 dash large gap + 8 dot dash + 9 dot dot dash + 10 triple + 11 thin-thick small gap + 12 thick-thin small gap + 13 thin-thick-thin small gap + 14 thin-thick medium gap + 15 thick-thin medium gap + 16 thin-thick-thin medium gap + 17 thin-thick large gap + 18 thick-thin large gap + 19 thin-thick-thin large gap + 20 wave + 21 double wave + 22 dash small gap + 23 dash dot stroked + 24 emboss 3D + 25 engrave 3D + codes 64 - 230 represent border art types and are used only for + page borders.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FF00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCTYPE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ico"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>color code (see chp.ico)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>00FF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ICO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dptSpace"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>width of space to maintain between border and text within + border. Must be 0 when BRC is a substructure of TC. Stored in + points.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1F00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DPTSPACE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fShadow"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, border is drawn with shadow. Must be 0 when BRC is a + substructure of the TC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FSHADOW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fFrame"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FFRAME</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused2_15"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED2_15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="BRC-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="BRC"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class BRC--> + <!--Class TC--> + <UML:Class xmi.id="TC" name="TC"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fFirstMerged"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set to 1 when cell is first cell of a range of cells that have + been merged. When a cell is merged, the display areas of the merged + cells are consolidated and the text within the cells is interpreted + as belonging to one text stream for purposes of calculating line + breaks.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0001</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FFIRSTMERGED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fMerged"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set to 1 when cell has been merged with preceding cell.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0002</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FMERGED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fVertical"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set to 1 when cell has vertical text flow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0004</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FVERTICAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fBackward"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>for a vertical table cell, text flow is bottom to top when 1 + and is bottom to top when 0.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0008</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FBACKWARD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fRotateFont"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set to 1 when cell has rotated characters (i.e. uses + @font)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0010</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FROTATEFONT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fVertMerge"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set to 1 when cell is vertically merged with the cell(s) above + and/or below. When cells are vertically merged, the display area of + the merged cells are consolidated. The consolidated area is used to + display the contents of the first vertically merged cell (the cell + with fVertRestart set to 1), and all other vertically merged cells + (those with fVertRestart set to 0) must be empty. Cells can only be + merged vertically if their left and right boundaries are (nearly) + identical (i.e. if corresponding entries in rgdxaCenter of the + table rows differ by at most 3).</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0020</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FVERTMERGE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fVertRestart"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>set to 1 when the cell is the first of a set of vertically + merged cells. The contents of a cell with fVertStart set to 1 are + displayed in the consolidated area belonging to the entire set of + vertically merged cells. Vertically merged cells with fVertRestart + set to 0 must be empty.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0040</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FVERTRESTART</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="vertAlign"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specifies the alignment of the cell contents relative to text + flow (e.g. in a cell with bottom to top text flow and bottom + vertical alignment, the text is shifted horizontally to match the + cell's right boundary): + 0 top + 1 center + 2 bottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0180</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:VERTALIGN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fUnused"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FE00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FUNUSED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="CellPreferredSize"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>preferred size of cell</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CellPrefferedSize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>BRC[cbrcTc] rgbrc: notational convenience for referring to + brcTop, brcLeft, etc. fields. + specification of the top border of a table cell</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCTOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification of left border of table row</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification of bottom border of table row</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCBOTTOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification of right border of table row.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCRIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="TC-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="TC"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class TC--> + <!--Class BKF--> + <UML:Class name="BKF" xmi.id="BKF"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="ibkl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>index to BKL entry in plcfbkl that describes the + ending position of this bookmark in the CP stream.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:IBKL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="itcFirst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when bkf.fCol is 1, this is the index to the first column of a + table column bookmark.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>007F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ITCFIRST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fPub"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, this indicates that this bookmark is marking the range + of a Macintosh Publisher section.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0080</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FPUB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="itcLim"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when bkf.fCol is 1, this is the index to limit column of a + table column bookmark.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7F00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ITCLIM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fCol"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when 1, this bookmark marks a range of columns in a table + specified by [bkf.itcFirst, bkf.itcLim).</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FCOL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="BKF-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="BKF"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class BKF--> + <!--Class LineProps--> + <UML:Class name="LineProps" xmi.id="LineProps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="linecolor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>color of line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINECOLOR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linewidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>width of line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEWIDTH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linetype"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>type of line, see border type code (BRC)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINETYPE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="LineProps-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="LineProps"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class LineProps--> + <!--Class TBD--> + <UML:Class xmi.id="TBD" name="TBD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="jc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>justification code + 0 left tab + 1 centered tab + 2 right tab + 3 decimal tab + 4 bar</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>07</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:JC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="tlc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>tab leader code + 0 no leader + 1 dotted leader + 2 hyphenated leader + 3 single line leader + 4 heavy line leader</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>38</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:TLC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused0_6"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>C0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED0_6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="TBD-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="TBD"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class TBD--> + <!--Class METAFILEPICT--> + <UML:Class xmi.id="METAFILEPICT" name="METAFILEPICT"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="mm"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Specifies the mapping mode in which the picture is drawn. </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:MM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="xExt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Specifies the size of the metafile picture for all modes except + the MM_ISOTROPIC and MM_ANISOTROPIC modes. (For more information + about these modes, see the yExt member.) The x-extent specifies the + width of the rectangle within which the picture is drawn. The + coordinates are in units that correspond to the mapping mode.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XEXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="yExt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Specifies the size of the metafile picture for all modes except + the MM_ISOTROPIC and MM_ANISOTROPIC modes. The y-extent specifies + the height of the rectangle within which the picture is drawn. The + coordinates are in units that correspond to the mapping mode. + For MM_ISOTROPIC and MM_ANISOTROPIC modes, which can be scaled, + the xExt and yExt members contain an optional suggested size in + MM_HIMETRIC units. + For MM_ANISOTROPIC pictures, xExt and yExt can be zero when no + suggested size is supplied. For MM_ISOTROPIC pictures, an aspect + ratio must be supplied even when no suggested size is given. (If a + suggested size is given, the aspect ratio is implied by the size.) + To give an aspect ratio without implying a suggested size, set xExt + and yExt to negative values whose ratio is the appropriate aspect + ratio. The magnitude of the negative xExt and yExt values is + ignored; only the ratio is used. + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:YEXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="hMF"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Identifies a memory metafile.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:HMF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="METAFILEPICT-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="METAFILEPICT"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class METAFILEPICT--> + <!--Class FFDATA--> + <UML:Class xmi.id="FFDATA" name="FFDATA"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="unknown"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unkonwn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dropdownIndex"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unkonwn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xfc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dropdownIndex</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fTooltip"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>tool tip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:tooltip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fNomark"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>no mark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:nomark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fUseSize"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>use size</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:useSize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fNumersOnly"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>numbers only</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:numbersOnly</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fDateOnly"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>date only</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dateOnly</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fUnused"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xe0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="size"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>size</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:size</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="hpsCheckbox"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:hpsCheckbox</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="title"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>title of the field</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xa</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fftitle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="String"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="FLT"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FLT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="default"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ffdefault</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="checked"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ffchecked</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U16"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="formatting"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ffformatting</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="help"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ffhelp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="tooltip"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fftooltip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FFDATA-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FFDATA"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FFDATA--> + <!--Class PICF--> + <UML:Class xmi.id="PICF" name="PICF"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="lcb"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>number of bytes in the PIC structure plus size of following + picture data which may be a Window's metafile, a bitmap, or the + filename of a TIFF file. In the case of a Macintosh PICT picture, + this includes the size of the PIC, the standard "x" metafile, and + the Macintosh PICT data. See Appendix B for more information.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LCB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cbHeader"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>number of bytes in the PIC (to allow for future + expansion).</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CBHEADER</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="mfp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>If a Windows metafile is stored immediately following the PIC + structure, the mfp is a Window's METAFILEPICT structure. When the + data immediately following the PIC is a TIFF filename, mfp.mm == 98 + If a bitmap is stored after the pic, mfp.mm == 99 + When the PIC describes a bitmap, mfp.xExt is the width of the + bitmap in pixels and mfp.yExt is the height of the bitmap in + pixels.. + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:MFP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="METAFILEPICT"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="bm_rcWinMF"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Window's bitmap structure when PIC describes a BITMAP (14 + bytes). + Rect for window origin and extents when metafile is stored -- + ignored if 0 (8 bytes).</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BM_RCWINMF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaGoal"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>horizontal measurement in twips of the rectangle the picture + should be imaged within. when scaling bitmaps, dxaGoal and dyaGoal + may be ignored if the operation would cause the bitmap to shrink or + grow by a non -power-of-two factor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DXAGOAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dyaGoal"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>vertical measurement in twips of the rectangle the picture + should be imaged within.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DYAGOAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="mx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>horizontal scaling factor supplied by user expressed in .001% + units.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:MX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="my"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>vertical scaling factor supplied by user expressed in .001% + units.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x22</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:MY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaCropLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the amount the picture has been cropped on the left in twips. + for all of the Crop values, a positive measurement means the + specified border has been moved inward from its original setting + and a negative measurement means the border has been moved outward + from its original setting.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DXACROPLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dyaCropTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the amount the picture has been cropped on the top in + twips.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x26</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DYACROPTOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaCropRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the amount the picture has been cropped on the right in + twips.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x28</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DXACROPRIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dyaCropBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the amount the picture has been cropped on the bottom in + twips.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DYACROPBOTTOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Obsolete, superseded by brcTop, etc. In WinWord 1.x, it was the + type of border to place around picture + 0 single + 1 thick + 2 double + 3 shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>000F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fFrameEmpty"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>picture consists of a single frame</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0010</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FFRAMEEMPTY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fBitmap"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>==1, when picture is just a bitmap</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0020</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FBITMAP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fDrawHatch"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>==1, when picture is an active OLE object</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0040</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FDRAWHATCH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fError"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>==1, when picture is just an error message</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0080</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FERROR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="bpp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>bits per pixel + 0 unknown + 1 monochrome + 4 VGA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FF00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BPP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification for border above picture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCTOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification for border to the left of picture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification for border below picture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x36</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCBOTTOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="brcRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>specification for border to the right of picture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCRIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dxaOrigin"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>horizontal offset of hand annotation origin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DXAORIGIN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="dyaOrigin"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>vertical offset of hand annotation origin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DYAORIGIN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cProps"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x42</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CPROPS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="DffRecord"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:DffRecord</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="DffRecord"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="noresolve"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="ffdata"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ffdata</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="FFDATA"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="noresolve"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="PICF-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="PICF"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class PICF--> + <!--Class FSPA--> + <UML:Class xmi.id="FSPA" name="FSPA"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>26</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="spid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape Identifier. Used in conjunction with the office art data + (found via fcDggInfo in the FIB) to find the actual + data for this shape.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:SPID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="xaLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>xa left of rectangle enclosing shape relative to the origin of + the shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XALEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="yaTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>ya top of rectangle enclosing shape relative to the origin of + the shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:YATOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="xaRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>xa right of rectangle enclosing shape relative to the origin of + the shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:XARIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="yaBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>ya bottom of the rectangle enclosing shape relative to the + origin of the shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:YABOTTOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fHdr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1 in the undo doc when shape is from the header doc, 0 + otherwise (undefined when not in the undo doc)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0001</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FHDR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="bx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>x position of shape relative to anchor CP + 0 relative to page margin + 1 relative to top of page + 2 relative to text (column for horizontal text; paragraph for + vertical text) + 3 reserved for future use</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0006</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="by"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>y position of shape relative to anchor CP + 0 relative to page margin + 1 relative to top of page + 2 relative to text (paragraph for horizontal text; column for + vertical text)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0018</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wr"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>text wrapping mode + 0 like 2, but doesn't require absolute object + 1 no text next to shape + 2 wrap around absolute object + 3 wrap as if no object present + 4 wrap tightly around object + 5 wrap tightly, but allow holes + 6-15 reserved for future use</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>01E0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wrk"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>text wrapping mode type (valid only for wrapping modes 2 and + 4 + 0 wrap both sides + 1 wrap only on left + 2 wrap only on right + 3 wrap only on largest side</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1E00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:WRK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fRcaSimple"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when set, temporarily overrides bx, by, forcing the xaLeft, + xaRight, yaTop, and yaBottom fields to all be page relative.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FRCASIMPLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fBelowText"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1 shape is below text + 0 shape is above text</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FBELOWTEXT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fAnchorLock"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1 anchor is locked + 0 anchor is not locked</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FANCHORLOCK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>count of textboxes in shape (undo doc only)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="shape"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="DffRecord"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FSPA-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FSPA"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FSPA--> + <!--Class FLD--> + <UML:Class xmi.id="FLD" name="FLD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="ch"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>type of field boundary the FLD describes: + 19 field begin mark + 20 field separator mark + 21 field end mark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused0_5"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>E0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED0_5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="flt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>fld.ch == 19 (field begin mark) -> U8 field type (see flt + table below). + fld.ch == 20 (field separator mark) -> not present + fld.ch == 21 (field end mark) -> + fDiffer:1 - ignored for saved file + fZombieEmbed:1 - 1 when result still believes this field is an + EMBED or LINK field. + fResultDirty:1 - when user has edited or formatted the result. == + 0 otherwise. + fResultEdited:1 - 1 when user has inserted text into or deleted + text from the result. + fLocked:1 - 1 when field is locked from recalc. + fPrivateResult:1 - 1 whenever the result of the field is never to + be shown. + fNested:1 - 1 when field is nested within another field. + fHasSep:1 - 1 when field has a field separator.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FLT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FLD-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FLD"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FLD--> + <!--Class Rectangle--> + <UML:Class xmi.id="Rectangle" name="Rectangle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="left"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>left margin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="top"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>top margin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="right"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>right margin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="bottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>bottom margin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="Rectangle-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="Rectangle"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class Rectangle--> + <!--Class FOPTE--> + <UML:Class xmi.id="FOPTE" name="FOPTE"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="withindex"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="pid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Property ID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3fff</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shppid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fBid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>value is a blip ID u2013 only valid if fComplex is FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfBid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fComplex"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>complex property, value is length</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfComplex</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="op"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="name"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpname</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="value"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpvalue</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="Value"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="stringValue"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpstringvalue</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="Value"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="noresolve"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FOPTE-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FOPTE"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FOPTE--> + <!--Class FDGG--> + <UML:Class xmi.id="FDGG" name="FDGG"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="spidMax"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The current maximum shape ID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpspidMax</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cidcl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The number of ID clusters (FIDCLs)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpcidcl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cspSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The total number of shapes saved (including deleted shapes, if undo information was saved)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpcspSaved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cdgSaved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The total number of drawings saved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpcdgSaved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FDGG-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FDGG"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FDGG--> + <!--Class FIDCL--> + <UML:Class xmi.id="FIDCL" name="FIDCL"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="dgid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>DG owning the SPIDs in this cluster</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpdgid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cspidCur"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>number of SPIDs used so far</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpcspidCur</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FIDCL-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FIDCL"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FIDCL--> + <!--Class FBSE--> + <UML:Class xmi.id="FBSE" name="FBSE"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x24</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="btWin32"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Required type on Win32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpbtWin32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="btMacOS"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Required type on Mac</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpbtMacOS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="rgbUid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Identifier of blip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shprgbUid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="arraycount"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="tag"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>currently unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shptag</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="size"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip size in stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpsize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cRef"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Reference count on the blip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x18</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpcRef</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="foDelay"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>File offset in the delay stream</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfoDelay</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="usage"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How this blip is used (MSOBLIPUSAGE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpusage</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cbName"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>length of the blip name</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x21</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpcbName</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused2"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>for the future</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x22</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpunused2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused3"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>for the future</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x23</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpunused3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FBSE-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FBSE"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FBSE--> + <!--Class FRD--> + <UML:Class xmi.id="FRD" name="FRD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="pid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FRD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FRD-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FRD"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FRD--> + <!--Class ATRD--> + <UML:Class xmi.id="ATRD" name="ATRD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>28</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="ibst"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>index into GrpXstAtnOwners</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:IBST</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ak"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0003</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:AK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="unused22_2"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FFFC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>:14</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:UNUSED22_2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="grfbmc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unused</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x18</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:GRFBMC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lTagBkmk"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when not -1, this tag identifies the annotation bookmark that + locates the range of CPs in the main document which this annotation + references.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LTAGBKMK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="xstUsrInitl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:xstUsrInitl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>pascal-style string holding initials of annotation author</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="ATRD-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="ATRD"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class ATRD--> + <!--Class FTXBXS--> + <UML:Class xmi.id="FTXBXS" name="FTXBXS"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>22</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="cTxbx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when not fReusable, counts the number of textboxes in this + story chain</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CTXBX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="iNextReuse"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>when fReusable, the index of the next in the linked list of + reusable FTXBXSs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:INEXTREUSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="cReusable"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>if fReusable, counts the number of reusable FTXBXSs follow this + one in the linked list</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CREUSABLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fReusable"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>this FTXBXS is not currently in use</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FREUSABLE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="reserved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xA</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:RESERVED</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape Identifier (see FSPA) for first Office Shape in textbox + chain.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="txidUndo"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:TXIDUNDO</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="S32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FTXBXS-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FTXBXS"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FTXBXS--> + <!--Class FDG--> + <UML:Class xmi.id="FDG" name="FDG"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="csp"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The number of shapes in this drawing</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:csp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="spidCur"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The last MSOSPID given to an SP in this DG</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:spidCur</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FDG-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FDG"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class FDG--> + <!--Class Tplc--> + <UML:Class xmi.id="Tplc" name="Tplc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fBuildIn"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fBuildIn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ilgbdM1"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7fff</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ilgbdM1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="lid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:lid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="Tplc-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="Tplc"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--Class Tplc--> + <!--WW8 resources--> + <!--SPRMS--> + <!--SPRM sprmPContextualSpacing--> + <UML:Class xmi.id="sprmPContextualSpacing" name="sprmPContextualSpacing"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x246D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPIContextualSpacing</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPContextualSpacing--> + <!--SPRM sprmPIstdPermute--> + <UML:Class xmi.id="sprmPIstdPermute" name="sprmPIstdPermute"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC601</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPIstdPermute</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPIstdPermute--> + <!--SPRM sprmPTabProps--> + <UML:Class xmi.id="sprmPTabProps" name="sprmPTabProps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x646B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPTabProps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPTabProps--> + <!--SPRM sprmTFCantSplit90--> + <UML:Class xmi.id="sprmTFCantSplit90" name="sprmTFCantSplit90"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3466</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTFCantSplit90</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTFCantSplit90--> + <!--SPRM sprmTCantSplit--> + <UML:Class xmi.id="sprmTCantSplit" name="sprmTCantSplit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3644</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCantSplit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTCantSplit--> + <!--SPRM sprmPIncLvl--> + <UML:Class xmi.id="sprmPIncLvl" name="sprmPIncLvl"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2602</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPIncLvl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPIncLvl--> + <!--SPRM sprmPJcExtra--> + <UML:Class xmi.id="sprmPJcExtra" name="sprmPJcExtra"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2461</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPJcExtra</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPJcExtra--> + <!--SPRM sprmPJc--> + <UML:Class xmi.id="sprmPJc" name="sprmPJc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2403</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPJc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPJc--> + <!--SPRM sprmPFSideBySide--> + <UML:Class xmi.id="sprmPFSideBySide" name="sprmPFSideBySide"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2404</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFSideBySide</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFSideBySide--> + <!--SPRM sprmPFKeep--> + <UML:Class xmi.id="sprmPFKeep" name="sprmPFKeep"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2405</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFKeep</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFKeep--> + <!--SPRM sprmPFKeepFollow--> + <UML:Class xmi.id="sprmPFKeepFollow" name="sprmPFKeepFollow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2406</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFKeepFollow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFKeepFollow--> + <!--SPRM sprmPFPageBreakBefore--> + <UML:Class xmi.id="sprmPFPageBreakBefore" name="sprmPFPageBreakBefore"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2407</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFPageBreakBefore</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFPageBreakBefore--> + <!--SPRM sprmPBrcl--> + <UML:Class xmi.id="sprmPBrcl" name="sprmPBrcl"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2408</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcl--> + <!--SPRM sprmPBrcp--> + <UML:Class xmi.id="sprmPBrcp" name="sprmPBrcp"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2409</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcp--> + <!--SPRM sprmPIlvl--> + <UML:Class xmi.id="sprmPIlvl" name="sprmPIlvl"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x260A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPIlvl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPIlvl--> + <!--SPRM sprmPIlfo--> + <UML:Class xmi.id="sprmPIlfo" name="sprmPIlfo"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x460B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPIlfo</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPIlfo--> + <!--SPRM sprmPFNoLineNumb--> + <UML:Class xmi.id="sprmPFNoLineNumb" name="sprmPFNoLineNumb"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x240C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFNoLineNumb</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFNoLineNumb--> + <!--SPRM sprmPChgTabsPapx--> + <UML:Class xmi.id="sprmPChgTabsPapx" name="sprmPChgTabsPapx"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nopayloadoffset"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC60D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPChgTabsPapx</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="dxaDel"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dxaDel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>array of tab positions for which tabs should be deleted</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="S16"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="dxaAdd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:dxaAdd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>array of tab positions for which tabs should be added</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="S16"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="tbdAdd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:tbdAdd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>array of tab descriptors corresponding to rgdxaAdd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="TBD"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPChgTabsPapx-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPChgTabsPapx"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPChgTabsPapx--> + <!--SPRM sprmPDxaRight--> + <UML:Class xmi.id="sprmPDxaRight" name="sprmPDxaRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x840E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaRight--> + <!--SPRM sprmPDxaLeft--> + <UML:Class xmi.id="sprmPDxaLeft" name="sprmPDxaLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x840F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaLeft--> + <!--SPRM sprmPNest--> + <UML:Class xmi.id="sprmPNest" name="sprmPNest"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4610</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPNest</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPNest--> + <!--SPRM sprmPDxaLeft180--> + <UML:Class xmi.id="sprmPDxaLeft180" name="sprmPDxaLeft180"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8411</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaLeft1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaLeft180--> + <!--SPRM sprmPDyaLine--> + <UML:Class xmi.id="sprmPDyaLine" name="sprmPDyaLine"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6412</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDyaLine</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDyaLine--> + <!--SPRM sprmPDyaBefore--> + <UML:Class xmi.id="sprmPDyaBefore" name="sprmPDyaBefore"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xA413</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDyaBefore</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDyaBefore--> + <!--SPRM sprmPDyaAfter--> + <UML:Class xmi.id="sprmPDyaAfter" name="sprmPDyaAfter"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xA414</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDyaAfter</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDyaAfter--> + <!--SPRM sprmPChgTabs--> + <UML:Class xmi.id="sprmPChgTabs" name="sprmPChgTabs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC615</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPChgTabs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPChgTabs--> + <!--SPRM sprmPFInTable--> + <UML:Class xmi.id="sprmPFInTable" name="sprmPFInTable"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2416</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFInTable</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFInTable--> + <!--SPRM sprmPCell--> + <UML:Class xmi.id="sprmPCell" name="sprmPCell"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x244b</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPCell</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPCell--> + <!--SPRM sprmPRow--> + <UML:Class xmi.id="sprmPRow" name="sprmPRow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x244c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPRow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPRow--> + <!--SPRM sprmPFTtp--> + <UML:Class xmi.id="sprmPFTtp" name="sprmPFTtp"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2417</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFTtp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFTtp--> + <!--SPRM sprmPDxaAbs--> + <UML:Class xmi.id="sprmPDxaAbs" name="sprmPDxaAbs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8418</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaAbs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaAbs--> + <!--SPRM sprmPDyaAbs--> + <UML:Class xmi.id="sprmPDyaAbs" name="sprmPDyaAbs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8419</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDyaAbs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDyaAbs--> + <!--SPRM sprmPDxaWidth--> + <UML:Class xmi.id="sprmPDxaWidth" name="sprmPDxaWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x841A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaWidth--> + <!--SPRM sprmPPc--> + <UML:Class xmi.id="sprmPPc" name="sprmPPc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x261B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPPc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPPc--> + <!--SPRM sprmPBrcTop10--> + <UML:Class xmi.id="sprmPBrcTop10" name="sprmPBrcTop10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x461C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcTop10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcTop10--> + <!--SPRM sprmPBrcLeft10--> + <UML:Class xmi.id="sprmPBrcLeft10" name="sprmPBrcLeft10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x461D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcLeft10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcLeft10--> + <!--SPRM sprmPBrcBottom10--> + <UML:Class xmi.id="sprmPBrcBottom10" name="sprmPBrcBottom10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x461E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcBottom10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcBottom10--> + <!--SPRM sprmPBrcRight10--> + <UML:Class xmi.id="sprmPBrcRight10" name="sprmPBrcRight10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x461F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcRight10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcRight10--> + <!--SPRM sprmPBrcBetween10--> + <UML:Class xmi.id="sprmPBrcBetween10" name="sprmPBrcBetween10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4620</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcBetween10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcBetween10--> + <!--SPRM sprmPBrcBar10--> + <UML:Class xmi.id="sprmPBrcBar10" name="sprmPBrcBar10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4621</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcBar10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPBrcBar10--> + <!--SPRM sprmPDxaFromText10--> + <UML:Class xmi.id="sprmPDxaFromText10" name="sprmPDxaFromText10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4622</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaFromText10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaFromText10--> + <!--SPRM sprmPWr--> + <UML:Class xmi.id="sprmPWr" name="sprmPWr"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2423</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPWr</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPWr--> + <!--SPRM sprmPBrcBar--> + <UML:Class xmi.id="sprmPBrcBar" name="sprmPBrcBar"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6629</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcBar</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBrcBar-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBrcBar"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBrcBar--> + <!--SPRM sprmPFNoAutoHyph--> + <UML:Class xmi.id="sprmPFNoAutoHyph" name="sprmPFNoAutoHyph"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x242A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFNoAutoHyph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFNoAutoHyph--> + <!--SPRM sprmPWHeightAbs--> + <UML:Class xmi.id="sprmPWHeightAbs" name="sprmPWHeightAbs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x442B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPWHeightAbs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPWHeightAbs--> + <!--SPRM sprmPDcs--> + <UML:Class xmi.id="sprmPDcs" name="sprmPDcs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x442C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDcs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDcs--> + <!--SPRM sprmPShd--> + <UML:Class xmi.id="sprmPShd" name="sprmPShd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x442D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPShd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPShd--> + <!--SPRM sprmPDyaFromText--> + <UML:Class xmi.id="sprmPDyaFromText" name="sprmPDyaFromText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x842E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDyaFromText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDyaFromText--> + <!--SPRM sprmPDxaFromText--> + <UML:Class xmi.id="sprmPDxaFromText" name="sprmPDxaFromText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x842F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaFromText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaFromText--> + <!--SPRM sprmPFLocked--> + <UML:Class xmi.id="sprmPFLocked" name="sprmPFLocked"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2430</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFLocked</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFLocked--> + <!--SPRM sprmPFWidowControl--> + <UML:Class xmi.id="sprmPFWidowControl" name="sprmPFWidowControl"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2431</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFWidowControl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFWidowControl--> + <!--SPRM sprmPRuler--> + <UML:Class xmi.id="sprmPRuler" name="sprmPRuler"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC632</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPRuler</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPRuler--> + <!--SPRM sprmPFKinsoku--> + <UML:Class xmi.id="sprmPFKinsoku" name="sprmPFKinsoku"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2433</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFKinsoku</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFKinsoku--> + <!--SPRM sprmPFWordWrap--> + <UML:Class xmi.id="sprmPFWordWrap" name="sprmPFWordWrap"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2434</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFWordWrap</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFWordWrap--> + <!--SPRM sprmPFOverflowPunct--> + <UML:Class xmi.id="sprmPFOverflowPunct" name="sprmPFOverflowPunct"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2435</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFOverflowPunct</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFOverflowPunct--> + <!--SPRM sprmPFTopLinePunct--> + <UML:Class xmi.id="sprmPFTopLinePunct" name="sprmPFTopLinePunct"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2436</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFTopLinePunct</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFTopLinePunct--> + <!--SPRM sprmPFAutoSpaceDE--> + <UML:Class xmi.id="sprmPFAutoSpaceDE" name="sprmPFAutoSpaceDE"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2437</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFAutoSpaceDE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFAutoSpaceDE--> + <!--SPRM sprmPFAutoSpaceDN--> + <UML:Class xmi.id="sprmPFAutoSpaceDN" name="sprmPFAutoSpaceDN"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2438</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFAutoSpaceDN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFAutoSpaceDN--> + <!--SPRM sprmPWAlignFont--> + <UML:Class xmi.id="sprmPWAlignFont" name="sprmPWAlignFont"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4439</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPWAlignFont</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPWAlignFont--> + <!--SPRM sprmPFrameTextFlow--> + <UML:Class xmi.id="sprmPFrameTextFlow" name="sprmPFrameTextFlow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x443A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFrameTextFlow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFrameTextFlow--> + <!--SPRM sprmPISnapBaseLine--> + <UML:Class xmi.id="sprmPISnapBaseLine" name="sprmPISnapBaseLine"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x243B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPISnapBaseLine</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPISnapBaseLine--> + <!--SPRM sprmPAnld--> + <UML:Class xmi.id="sprmPAnld" name="sprmPAnld"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC63E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPAnld</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPAnld--> + <!--SPRM sprmPPropRMark--> + <UML:Class xmi.id="sprmPPropRMark" name="sprmPPropRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC63F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPPropRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPPropRMark--> + <!--SPRM sprmPOutLvl--> + <UML:Class xmi.id="sprmPOutLvl" name="sprmPOutLvl"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2640</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPOutLvl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPOutLvl--> + <!--SPRM sprmPFBiDi--> + <UML:Class xmi.id="sprmPFBiDi" name="sprmPFBiDi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2441</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFBiDi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFBiDi--> + <!--SPRM sprmPFNumRMIns--> + <UML:Class xmi.id="sprmPFNumRMIns" name="sprmPFNumRMIns"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2443</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFNumRMIns</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFNumRMIns--> + <!--SPRM sprmPCrLf--> + <UML:Class xmi.id="sprmPCrLf" name="sprmPCrLf"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2444</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPCrLf</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPCrLf--> + <!--SPRM sprmPNumRM--> + <UML:Class xmi.id="sprmPNumRM" name="sprmPNumRM"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xC645</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPNumRM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPNumRM--> + <!--SPRM sprmPHugePapx--> + <UML:Class xmi.id="sprmPHugePapx" name="sprmPHugePapx"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6645</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPHugePapx</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPHugePapx--> + <!--SPRM sprmPFUsePgsuSettings--> + <UML:Class xmi.id="sprmPFUsePgsuSettings" name="sprmPFUsePgsuSettings"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2447</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFUsePgsuSettings</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFUsePgsuSettings--> + <!--SPRM sprmPFAdjustRight--> + <UML:Class xmi.id="sprmPFAdjustRight" name="sprmPFAdjustRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2448</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPFAdjustRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPFAdjustRight--> + <!--SPRM sprmCFRMarkDel--> + <UML:Class xmi.id="sprmCFRMarkDel" name="sprmCFRMarkDel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0800</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFRMarkDel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFRMarkDel--> + <!--SPRM sprmCFRMark--> + <UML:Class xmi.id="sprmCFRMark" name="sprmCFRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0801</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFRMark--> + <!--SPRM sprmCFFldVanish--> + <UML:Class xmi.id="sprmCFFldVanish" name="sprmCFFldVanish"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0802</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFFldVanish</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFFldVanish--> + <!--SPRM sprmCPicLocation--> + <UML:Class xmi.id="sprmCPicLocation" name="sprmCPicLocation"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6A03</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCPicLocation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fcPic"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>picture location</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcPic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmCPicLocation-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmCPicLocation"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmCPicLocation--> + <!--SPRM sprmCIbstRMark--> + <UML:Class xmi.id="sprmCIbstRMark" name="sprmCIbstRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4804</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIbstRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIbstRMark--> + <!--SPRM sprmCDttmRMark--> + <UML:Class xmi.id="sprmCDttmRMark" name="sprmCDttmRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6805</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCDttmRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCDttmRMark--> + <!--SPRM sprmCFData--> + <UML:Class xmi.id="sprmCFData" name="sprmCFData"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0806</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFData</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFData--> + <!--SPRM sprmCIdslRMark--> + <UML:Class xmi.id="sprmCIdslRMark" name="sprmCIdslRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4807</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIdslRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIdslRMark--> + <!--SPRM sprmCChs--> + <UML:Class xmi.id="sprmCChs" name="sprmCChs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xEA08</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCChs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCChs--> + <!--SPRM sprmCSymbol--> + <UML:Class xmi.id="sprmCSymbol" name="sprmCSymbol"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6A09</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCSymbol</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="font"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>index of font for symbol in font table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x02</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:FONT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="char"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character code of symbol</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x04</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CHAR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmCSymbol-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmCSymbol"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmCSymbol--> + <!--SPRM sprmCFOle2--> + <UML:Class xmi.id="sprmCFOle2" name="sprmCFOle2"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x080A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFOle2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFOle2--> + <!--SPRM sprmCIdCharType--> + <UML:Class xmi.id="sprmCIdCharType" name="sprmCIdCharType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x480B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIdCharType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIdCharType--> + <!--SPRM sprmCHighlight--> + <UML:Class xmi.id="sprmCHighlight" name="sprmCHighlight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A0C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHighlight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHighlight--> + <!--SPRM sprmCObjLocation--> + <UML:Class xmi.id="sprmCObjLocation" name="sprmCObjLocation"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x680E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCObjLocation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCObjLocation--> + <!--SPRM sprmCFFtcAsciSymb--> + <UML:Class xmi.id="sprmCFFtcAsciSymb" name="sprmCFFtcAsciSymb"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFFtcAsciSymb</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFFtcAsciSymb--> + <!--SPRM sprmCIstd--> + <UML:Class xmi.id="sprmCIstd" name="sprmCIstd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A30</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIstd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIstd--> + <!--SPRM sprmCIstdPermute--> + <UML:Class xmi.id="sprmCIstdPermute" name="sprmCIstdPermute"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA31</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIstdPermute</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIstdPermute--> + <!--SPRM sprmCDefault--> + <UML:Class xmi.id="sprmCDefault" name="sprmCDefault"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCDefault</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCDefault--> + <!--SPRM sprmCPlain--> + <UML:Class xmi.id="sprmCPlain" name="sprmCPlain"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A33</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCPlain</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCPlain--> + <!--SPRM sprmCKcd--> + <UML:Class xmi.id="sprmCKcd" name="sprmCKcd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A34</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCKcd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCKcd--> + <!--SPRM sprmCFBold--> + <UML:Class xmi.id="sprmCFBold" name="sprmCFBold"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0835</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFBold</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFBold--> + <!--SPRM sprmCFItalic--> + <UML:Class xmi.id="sprmCFItalic" name="sprmCFItalic"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0836</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFItalic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFItalic--> + <!--SPRM sprmCFStrike--> + <UML:Class xmi.id="sprmCFStrike" name="sprmCFStrike"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0837</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFStrike</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFStrike--> + <!--SPRM sprmCFOutline--> + <UML:Class xmi.id="sprmCFOutline" name="sprmCFOutline"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0838</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFOutline</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFOutline--> + <!--SPRM sprmCFShadow--> + <UML:Class xmi.id="sprmCFShadow" name="sprmCFShadow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0839</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFShadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFShadow--> + <!--SPRM sprmCFSmallCaps--> + <UML:Class xmi.id="sprmCFSmallCaps" name="sprmCFSmallCaps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x083A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFSmallCaps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFSmallCaps--> + <!--SPRM sprmCFCaps--> + <UML:Class xmi.id="sprmCFCaps" name="sprmCFCaps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x083B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFCaps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFCaps--> + <!--SPRM sprmCFVanish--> + <UML:Class xmi.id="sprmCFVanish" name="sprmCFVanish"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x083C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFVanish</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFVanish--> + <!--SPRM sprmCFtcDefault--> + <UML:Class xmi.id="sprmCFtcDefault" name="sprmCFtcDefault"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A3D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFtcDefault</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFtcDefault--> + <!--SPRM sprmCKul--> + <UML:Class xmi.id="sprmCKul" name="sprmCKul"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A3E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCKul</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCKul--> + <!--SPRM sprmCSizePos--> + <UML:Class xmi.id="sprmCSizePos" name="sprmCSizePos"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xEA3F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCSizePos</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCSizePos--> + <!--SPRM sprmCDxaSpace--> + <UML:Class xmi.id="sprmCDxaSpace" name="sprmCDxaSpace"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8840</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCDxaSpace</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCDxaSpace--> + <!--SPRM sprmCLid--> + <UML:Class xmi.id="sprmCLid" name="sprmCLid"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A41</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCLid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCLid--> + <!--SPRM sprmCIco--> + <UML:Class xmi.id="sprmCIco" name="sprmCIco"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A42</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIco</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIco--> + <!--SPRM sprmCHps--> + <UML:Class xmi.id="sprmCHps" name="sprmCHps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A43</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHps--> + <!--SPRM sprmCHpsInc--> + <UML:Class xmi.id="sprmCHpsInc" name="sprmCHpsInc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A44</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsInc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsInc--> + <!--SPRM sprmCHpsPos--> + <UML:Class xmi.id="sprmCHpsPos" name="sprmCHpsPos"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4845</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsPos</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsPos--> + <!--SPRM sprmCHpsPosAdj--> + <UML:Class xmi.id="sprmCHpsPosAdj" name="sprmCHpsPosAdj"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A46</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsPosAdj</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsPosAdj--> + <!--SPRM sprmCMajority--> + <UML:Class xmi.id="sprmCMajority" name="sprmCMajority"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA47</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCMajority</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCMajority--> + <!--SPRM sprmCIss--> + <UML:Class xmi.id="sprmCIss" name="sprmCIss"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A48</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIss</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIss--> + <!--SPRM sprmCHpsNew50--> + <UML:Class xmi.id="sprmCHpsNew50" name="sprmCHpsNew50"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA49</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsNew50</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsNew50--> + <!--SPRM sprmCHpsInc1--> + <UML:Class xmi.id="sprmCHpsInc1" name="sprmCHpsInc1"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA4A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsInc1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsInc1--> + <!--SPRM sprmCHpsKern--> + <UML:Class xmi.id="sprmCHpsKern" name="sprmCHpsKern"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x484B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsKern</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsKern--> + <!--SPRM sprmCMajority50--> + <UML:Class xmi.id="sprmCMajority50" name="sprmCMajority50"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA4C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCMajority50</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCMajority50--> + <!--SPRM sprmCHpsMul--> + <UML:Class xmi.id="sprmCHpsMul" name="sprmCHpsMul"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A4D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsMul</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsMul--> + <!--SPRM sprmCYsri--> + <UML:Class xmi.id="sprmCYsri" name="sprmCYsri"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x484E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCYsri</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCYsri--> + <!--SPRM sprmCRgFtc0--> + <UML:Class xmi.id="sprmCRgFtc0" name="sprmCRgFtc0"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A4F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRgFtc0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRgFtc0--> + <!--SPRM sprmCRgFtc1--> + <UML:Class xmi.id="sprmCRgFtc1" name="sprmCRgFtc1"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A50</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRgFtc1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRgFtc1--> + <!--SPRM sprmCRgFtc2--> + <UML:Class xmi.id="sprmCRgFtc2" name="sprmCRgFtc2"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A51</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRgFtc2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRgFtc2--> + <!--SPRM sprmCCharScale--> + <UML:Class xmi.id="sprmCCharScale" name="sprmCCharScale"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4852</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCCharScale</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCCharScale--> + <!--SPRM sprmCFDStrike--> + <UML:Class xmi.id="sprmCFDStrike" name="sprmCFDStrike"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2A53</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFDStrike</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFDStrike--> + <!--SPRM sprmCFImprint--> + <UML:Class xmi.id="sprmCFImprint" name="sprmCFImprint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0854</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFImprint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFImprint--> + <!--SPRM sprmCFNoProof--> + <UML:Class xmi.id="sprmCFNoProof" name="sprmCFNoProof"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0875</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFNoProof</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFNoProof--> + <!--SPRM sprmCFspecVanish--> + <UML:Class xmi.id="sprmCFspecVanish" name="sprmCFspecVanish"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0818</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFspecVanish</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFspecVanish--> + <!--SPRM sprmCFitText--> + <UML:Class xmi.id="sprmCFitText" name="sprmCFitText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xca76</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFitText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFitText--> + <!--SPRM sprmCComplexScript--> + <UML:Class xmi.id="sprmCComplexScript" name="sprmCComplexScript"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x882</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCComplexScript</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCComplexScript--> + <!--SPRM sprmPTightWrap--> + <UML:Class xmi.id="sprmPTightWrap" name="sprmPTightWrap"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2471</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPTightWrap</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPTightWrap--> + <!--SPRM sprmCFSpec--> + <UML:Class xmi.id="sprmCFSpec" name="sprmCFSpec"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0855</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFSpec</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFSpec--> + <!--SPRM sprmCFObj--> + <UML:Class xmi.id="sprmCFObj" name="sprmCFObj"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0856</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFObj</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFObj--> + <!--SPRM sprmCPropRMark--> + <UML:Class xmi.id="sprmCPropRMark" name="sprmCPropRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA57</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCPropRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCPropRMark--> + <!--SPRM sprmCFEmboss--> + <UML:Class xmi.id="sprmCFEmboss" name="sprmCFEmboss"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0858</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFEmboss</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFEmboss--> + <!--SPRM sprmCSfxText--> + <UML:Class xmi.id="sprmCSfxText" name="sprmCSfxText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2859</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCSfxText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCSfxText--> + <!--SPRM sprmCFBiDi--> + <UML:Class xmi.id="sprmCFBiDi" name="sprmCFBiDi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x085A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFBiDi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFBiDi--> + <!--SPRM sprmCFDiacColor--> + <UML:Class xmi.id="sprmCFDiacColor" name="sprmCFDiacColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x085B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFDiacColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFDiacColor--> + <!--SPRM sprmCFBoldBi--> + <UML:Class xmi.id="sprmCFBoldBi" name="sprmCFBoldBi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x085C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFBoldBi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFBoldBi--> + <!--SPRM sprmCFItalicBi--> + <UML:Class xmi.id="sprmCFItalicBi" name="sprmCFItalicBi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x085D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFItalicBi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFItalicBi--> + <!--SPRM sprmCFtcBi--> + <UML:Class xmi.id="sprmCFtcBi" name="sprmCFtcBi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A5E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFtcBi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFtcBi--> + <!--SPRM sprmCLidBi--> + <UML:Class xmi.id="sprmCLidBi" name="sprmCLidBi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x485F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCLidBi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCLidBi--> + <!--SPRM sprmCIcoBi--> + <UML:Class xmi.id="sprmCIcoBi" name="sprmCIcoBi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A60</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIcoBi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIcoBi--> + <!--SPRM sprmCHpsBi--> + <UML:Class xmi.id="sprmCHpsBi" name="sprmCHpsBi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4A61</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCHpsBi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCHpsBi--> + <!--SPRM sprmCDispFldRMark--> + <UML:Class xmi.id="sprmCDispFldRMark" name="sprmCDispFldRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA62</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCDispFldRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCDispFldRMark--> + <!--SPRM sprmCIbstRMarkDel--> + <UML:Class xmi.id="sprmCIbstRMarkDel" name="sprmCIbstRMarkDel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4863</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIbstRMarkDel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIbstRMarkDel--> + <!--SPRM sprmCDttmRMarkDel--> + <UML:Class xmi.id="sprmCDttmRMarkDel" name="sprmCDttmRMarkDel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6864</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCDttmRMarkDel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCDttmRMarkDel--> + <!--SPRM sprmCBrc--> + <UML:Class xmi.id="sprmCBrc" name="sprmCBrc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6865</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCBrc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCBrc--> + <!--SPRM sprmCShd--> + <UML:Class xmi.id="sprmCShd" name="sprmCShd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4866</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCShd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCShd--> + <!--SPRM sprmCIdslRMarkDel--> + <UML:Class xmi.id="sprmCIdslRMarkDel" name="sprmCIdslRMarkDel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4867</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIdslRMarkDel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIdslRMarkDel--> + <!--SPRM sprmCFUsePgsuSettings--> + <UML:Class xmi.id="sprmCFUsePgsuSettings" name="sprmCFUsePgsuSettings"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0868</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCFUsePgsuSettings</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCFUsePgsuSettings--> + <!--SPRM sprmCCpg--> + <UML:Class xmi.id="sprmCCpg" name="sprmCCpg"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x486B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCCpg</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCCpg--> + <!--SPRM sprmCRgLid0_80--> + <UML:Class xmi.id="sprmCRgLid0_80" name="sprmCRgLid0_80"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x486D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRgLid0_80</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRgLid0_80--> + <!--SPRM sprmCRgLid1--> + <UML:Class xmi.id="sprmCRgLid1" name="sprmCRgLid1"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x486E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRgLid1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRgLid1--> + <!--SPRM sprmCIdctHint--> + <UML:Class xmi.id="sprmCIdctHint" name="sprmCIdctHint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x286F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCIdctHint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCIdctHint--> + <!--SPRM sprmPicBrcl--> + <UML:Class xmi.id="sprmPicBrcl" name="sprmPicBrcl"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2E00</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPicBrcl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPicBrcl--> + <!--SPRM sprmPicScale--> + <UML:Class xmi.id="sprmPicScale" name="sprmPicScale"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCE01</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPicScale</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPicScale--> + <!--SPRM sprmPicBrcTop--> + <UML:Class xmi.id="sprmPicBrcTop" name="sprmPicBrcTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6C02</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPicBrcTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPicBrcTop--> + <!--SPRM sprmPicBrcLeft--> + <UML:Class xmi.id="sprmPicBrcLeft" name="sprmPicBrcLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6C03</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPicBrcLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPicBrcLeft--> + <!--SPRM sprmPicBrcBottom--> + <UML:Class xmi.id="sprmPicBrcBottom" name="sprmPicBrcBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6C04</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPicBrcBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPicBrcBottom--> + <!--SPRM sprmPicBrcRight--> + <UML:Class xmi.id="sprmPicBrcRight" name="sprmPicBrcRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6C05</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPicBrcRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPicBrcRight--> + <!--SPRM sprmScnsPgn--> + <UML:Class xmi.id="sprmScnsPgn" name="sprmScnsPgn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmScnsPgn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmScnsPgn--> + <!--SPRM sprmSiHeadingPgn--> + <UML:Class xmi.id="sprmSiHeadingPgn" name="sprmSiHeadingPgn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3001</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSiHeadingPgn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSiHeadingPgn--> + <!--SPRM sprmSOlstAnm--> + <UML:Class xmi.id="sprmSOlstAnm" name="sprmSOlstAnm"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD202</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSOlstAnm</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSOlstAnm--> + <!--SPRM sprmSDxaColWidth--> + <UML:Class xmi.id="sprmSDxaColWidth" name="sprmSDxaColWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xF203</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaColWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaColWidth--> + <!--SPRM sprmSDxaColSpacing--> + <UML:Class xmi.id="sprmSDxaColSpacing" name="sprmSDxaColSpacing"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xF204</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaColSpacing</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaColSpacing--> + <!--SPRM sprmSFEvenlySpaced--> + <UML:Class xmi.id="sprmSFEvenlySpaced" name="sprmSFEvenlySpaced"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3005</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFEvenlySpaced</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFEvenlySpaced--> + <!--SPRM sprmSFProtected--> + <UML:Class xmi.id="sprmSFProtected" name="sprmSFProtected"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3006</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFProtected</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFProtected--> + <!--SPRM sprmSDmBinFirst--> + <UML:Class xmi.id="sprmSDmBinFirst" name="sprmSDmBinFirst"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5007</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDmBinFirst</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDmBinFirst--> + <!--SPRM sprmSDmBinOther--> + <UML:Class xmi.id="sprmSDmBinOther" name="sprmSDmBinOther"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5008</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDmBinOther</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDmBinOther--> + <!--SPRM sprmSBkc--> + <UML:Class xmi.id="sprmSBkc" name="sprmSBkc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3009</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBkc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBkc--> + <!--SPRM sprmSFTitlePage--> + <UML:Class xmi.id="sprmSFTitlePage" name="sprmSFTitlePage"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x300A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFTitlePage</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFTitlePage--> + <!--SPRM sprmSCcolumns--> + <UML:Class xmi.id="sprmSCcolumns" name="sprmSCcolumns"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x500B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSCcolumns</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSCcolumns--> + <!--SPRM sprmSDxaColumns--> + <UML:Class xmi.id="sprmSDxaColumns" name="sprmSDxaColumns"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x900C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaColumns</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaColumns--> + <!--SPRM sprmSFAutoPgn--> + <UML:Class xmi.id="sprmSFAutoPgn" name="sprmSFAutoPgn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x300D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFAutoPgn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFAutoPgn--> + <!--SPRM sprmSNfcPgn--> + <UML:Class xmi.id="sprmSNfcPgn" name="sprmSNfcPgn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x300E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSNfcPgn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSNfcPgn--> + <!--SPRM sprmSDyaPgn--> + <UML:Class xmi.id="sprmSDyaPgn" name="sprmSDyaPgn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB00F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDyaPgn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDyaPgn--> + <!--SPRM sprmSDxaPgn--> + <UML:Class xmi.id="sprmSDxaPgn" name="sprmSDxaPgn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB010</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaPgn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaPgn--> + <!--SPRM sprmSFPgnRestart--> + <UML:Class xmi.id="sprmSFPgnRestart" name="sprmSFPgnRestart"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3011</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFPgnRestart</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFPgnRestart--> + <!--SPRM sprmSFEndnote--> + <UML:Class xmi.id="sprmSFEndnote" name="sprmSFEndnote"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3012</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFEndnote</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFEndnote--> + <!--SPRM sprmSLnc--> + <UML:Class xmi.id="sprmSLnc" name="sprmSLnc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3013</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSLnc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSLnc--> + <!--SPRM sprmSGprfIhdt--> + <UML:Class xmi.id="sprmSGprfIhdt" name="sprmSGprfIhdt"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3014</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSGprfIhdt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSGprfIhdt--> + <!--SPRM sprmSNLnnMod--> + <UML:Class xmi.id="sprmSNLnnMod" name="sprmSNLnnMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5015</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSNLnnMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSNLnnMod--> + <!--SPRM sprmSDxaLnn--> + <UML:Class xmi.id="sprmSDxaLnn" name="sprmSDxaLnn"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9016</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaLnn</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaLnn--> + <!--SPRM sprmSDyaHdrTop--> + <UML:Class xmi.id="sprmSDyaHdrTop" name="sprmSDyaHdrTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB017</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDyaHdrTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDyaHdrTop--> + <!--SPRM sprmSDyaHdrBottom--> + <UML:Class xmi.id="sprmSDyaHdrBottom" name="sprmSDyaHdrBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB018</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDyaHdrBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDyaHdrBottom--> + <!--SPRM sprmSLBetween--> + <UML:Class xmi.id="sprmSLBetween" name="sprmSLBetween"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3019</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSLBetween</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSLBetween--> + <!--SPRM sprmSVjc--> + <UML:Class xmi.id="sprmSVjc" name="sprmSVjc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x301A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSVjc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSVjc--> + <!--SPRM sprmSLnnMin--> + <UML:Class xmi.id="sprmSLnnMin" name="sprmSLnnMin"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x501B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSLnnMin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSLnnMin--> + <!--SPRM sprmSPgnStart--> + <UML:Class xmi.id="sprmSPgnStart" name="sprmSPgnStart"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x501C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSPgnStart</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSPgnStart--> + <!--SPRM sprmSBOrientation--> + <UML:Class xmi.id="sprmSBOrientation" name="sprmSBOrientation"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x301D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBOrientation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBOrientation--> + <!--SPRM sprmSBCustomize--> + <UML:Class xmi.id="sprmSBCustomize" name="sprmSBCustomize"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x301E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBCustomize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBCustomize--> + <!--SPRM sprmSXaPage--> + <UML:Class xmi.id="sprmSXaPage" name="sprmSXaPage"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB01F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSXaPage</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSXaPage--> + <!--SPRM sprmSYaPage--> + <UML:Class xmi.id="sprmSYaPage" name="sprmSYaPage"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB020</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSYaPage</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSYaPage--> + <!--SPRM sprmSDxaLeft--> + <UML:Class xmi.id="sprmSDxaLeft" name="sprmSDxaLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB021</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaLeft--> + <!--SPRM sprmSDxaRight--> + <UML:Class xmi.id="sprmSDxaRight" name="sprmSDxaRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB022</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxaRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxaRight--> + <!--SPRM sprmSDyaTop--> + <UML:Class xmi.id="sprmSDyaTop" name="sprmSDyaTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9023</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDyaTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDyaTop--> + <!--SPRM sprmSDyaBottom--> + <UML:Class xmi.id="sprmSDyaBottom" name="sprmSDyaBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9024</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDyaBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDyaBottom--> + <!--SPRM sprmSDzaGutter--> + <UML:Class xmi.id="sprmSDzaGutter" name="sprmSDzaGutter"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xB025</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDzaGutter</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDzaGutter--> + <!--SPRM sprmSDmPaperReq--> + <UML:Class xmi.id="sprmSDmPaperReq" name="sprmSDmPaperReq"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5026</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDmPaperReq</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDmPaperReq--> + <!--SPRM sprmSPropRMark--> + <UML:Class xmi.id="sprmSPropRMark" name="sprmSPropRMark"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD227</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSPropRMark</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSPropRMark--> + <!--SPRM sprmSFBiDi--> + <UML:Class xmi.id="sprmSFBiDi" name="sprmSFBiDi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3228</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFBiDi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFBiDi--> + <!--SPRM sprmSFFacingCol--> + <UML:Class xmi.id="sprmSFFacingCol" name="sprmSFFacingCol"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3229</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFFacingCol</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFFacingCol--> + <!--SPRM sprmSFRTLGutter--> + <UML:Class xmi.id="sprmSFRTLGutter" name="sprmSFRTLGutter"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x322A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSFRTLGutter</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSFRTLGutter--> + <!--SPRM sprmSBrcTop--> + <UML:Class xmi.id="sprmSBrcTop" name="sprmSBrcTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x702B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBrcTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBrcTop--> + <!--SPRM sprmSBrcLeft--> + <UML:Class xmi.id="sprmSBrcLeft" name="sprmSBrcLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x702C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBrcLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBrcLeft--> + <!--SPRM sprmSBrcBottom--> + <UML:Class xmi.id="sprmSBrcBottom" name="sprmSBrcBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x702D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBrcBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBrcBottom--> + <!--SPRM sprmSBrcRight--> + <UML:Class xmi.id="sprmSBrcRight" name="sprmSBrcRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x702E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSBrcRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSBrcRight--> + <!--SPRM sprmSPgbProp--> + <UML:Class xmi.id="sprmSPgbProp" name="sprmSPgbProp"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x522F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSPgbProp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSPgbProp--> + <!--SPRM sprmSDxtCharSpace--> + <UML:Class xmi.id="sprmSDxtCharSpace" name="sprmSDxtCharSpace"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7030</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDxtCharSpace</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDxtCharSpace--> + <!--SPRM sprmSDyaLinePitch--> + <UML:Class xmi.id="sprmSDyaLinePitch" name="sprmSDyaLinePitch"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9031</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSDyaLinePitch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSDyaLinePitch--> + <!--SPRM sprmSClm--> + <UML:Class xmi.id="sprmSClm" name="sprmSClm"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5032</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSClm</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSClm--> + <!--SPRM sprmSTextFlow--> + <UML:Class xmi.id="sprmSTextFlow" name="sprmSTextFlow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5033</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmSTextFlow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmSTextFlow--> + <!--SPRM sprmTJc--> + <UML:Class xmi.id="sprmTJc" name="sprmTJc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTJc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTJc--> + <!--SPRM sprmTDxaLeft--> + <UML:Class xmi.id="sprmTDxaLeft" name="sprmTDxaLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9601</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDxaLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDxaLeft--> + <!--SPRM sprmTDxaGapHalf--> + <UML:Class xmi.id="sprmTDxaGapHalf" name="sprmTDxaGapHalf"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9602</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDxaGapHalf</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDxaGapHalf--> + <!--SPRM sprmTFCantSplit--> + <UML:Class xmi.id="sprmTFCantSplit" name="sprmTFCantSplit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3403</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTFCantSplit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTFCantSplit--> + <!--SPRM sprmTTableHeader--> + <UML:Class xmi.id="sprmTTableHeader" name="sprmTTableHeader"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3404</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTTableHeader</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTTableHeader--> + <!--SPRM sprmTTableBorders--> + <UML:Class xmi.id="sprmTTableBorders" name="sprmTTableBorders"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD605</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTTableBorders</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="rgbbrc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:rgbrc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="BRC"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTTableBorders-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTTableBorders"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTTableBorders--> + <!--SPRM sprmTDefTable10--> + <UML:Class xmi.id="sprmTDefTable10" name="sprmTDefTable10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD606</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDefTable10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDefTable10--> + <!--SPRM sprmTDyaRowHeight--> + <UML:Class xmi.id="sprmTDyaRowHeight" name="sprmTDyaRowHeight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9407</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDyaRowHeight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDyaRowHeight--> + <!--SPRM sprmTDefTable--> + <UML:Class xmi.id="sprmTDefTable" name="sprmTDefTable"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD608</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDefTable</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="cellx"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cellx</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U16"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="tc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:tc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="TC"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTDefTable-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTDefTable"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTDefTable--> + <!--SPRM sprmTDefTableShd--> + <UML:Class xmi.id="sprmTDefTableShd" name="sprmTDefTableShd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD609</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDefTableShd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="shd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="SHD"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTDefTableShd-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTDefTableShd"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTDefTableShd--> + <!--SPRM sprmTCellShd--> + <UML:Class xmi.id="sprmTCellShd" name="sprmTCellShd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD612</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellShd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="shd"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cellShd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="CellShd"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCelShd-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellShd"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellShd--> + <!--SPRM sprmTTlp--> + <UML:Class xmi.id="sprmTTlp" name="sprmTTlp"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x740A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTTlp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:Classifier.feature> + <UML:Attribute name="itl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:itl</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlBorders"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlBorders</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlShading"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlShading</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlFont"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlFont</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlBestFit"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlBestFit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlHdrRows"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlHdrRows</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlLastRow"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlLastRow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlHdrCols"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlHdrCols</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlLastCol"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x100</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlLastCol</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlNoRowBands"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x200</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlNoRowBands</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="fatlNoColBands"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fatlNoColBands</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTTlp-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTTlp"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTTlp--> + <!--SPRM sprmTFBiDi--> + <UML:Class xmi.id="sprmTFBiDi" name="sprmTFBiDi"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x560B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTFBiDi</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTFBiDi--> + <!--SPRM sprmTHTMLProps--> + <UML:Class xmi.id="sprmTHTMLProps" name="sprmTHTMLProps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x740C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTHTMLProps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTHTMLProps--> + <!--SPRM sprmTSetBrc--> + <UML:Class xmi.id="sprmTSetBrc" name="sprmTSetBrc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD620</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTSetBrc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTSetBrc--> + <!--SPRM sprmTInsert--> + <UML:Class xmi.id="sprmTInsert" name="sprmTInsert"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7621</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTInsert</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTInsert--> + <!--SPRM sprmTDelete--> + <UML:Class xmi.id="sprmTDelete" name="sprmTDelete"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5622</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDelete</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDelete--> + <!--SPRM sprmTDxaCol--> + <UML:Class xmi.id="sprmTDxaCol" name="sprmTDxaCol"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7623</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDxaCol</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDxaCol--> + <!--SPRM sprmTMerge--> + <UML:Class xmi.id="sprmTMerge" name="sprmTMerge"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5624</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTMerge</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTMerge--> + <!--SPRM sprmTSplit--> + <UML:Class xmi.id="sprmTSplit" name="sprmTSplit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5625</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTSplit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTSplit--> + <!--SPRM sprmTSetBrc10--> + <UML:Class xmi.id="sprmTSetBrc10" name="sprmTSetBrc10"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD626</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTSetBrc10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTSetBrc10--> + <!--SPRM sprmTSetShd--> + <UML:Class xmi.id="sprmTSetShd" name="sprmTSetShd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7627</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTSetShd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTSetShd--> + <!--SPRM sprmTSetShdOdd--> + <UML:Class xmi.id="sprmTSetShdOdd" name="sprmTSetShdOdd"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7628</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTSetShdOdd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTSetShdOdd--> + <!--SPRM sprmTTextFlow--> + <UML:Class xmi.id="sprmTTextFlow" name="sprmTTextFlow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7629</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTTextFlow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTTextFlow--> + <!--SPRM sprmTDiagLine--> + <UML:Class xmi.id="sprmTDiagLine" name="sprmTDiagLine"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD62A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDiagLine</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDiagLine--> + <!--SPRM sprmTVertMerge--> + <UML:Class xmi.id="sprmTVertMerge" name="sprmTVertMerge"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD62B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTVertMerge</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTVertMerge--> + <!--SPRM sprmTVertAlign--> + <UML:Class xmi.id="sprmTVertAlign" name="sprmTVertAlign"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD62C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTVertAlign</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTVertAlign--> + <!--SPRM sprmTCellTopColor--> + <UML:Class xmi.id="sprmTCellTopColor" name="sprmTCellTopColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD61A</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellTopColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="cellTopColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cellTopColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCellTopColor-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellTopColor"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellTopColor--> + <!--SPRM sprmTCellLeftColor--> + <UML:Class xmi.id="sprmTCellLeftColor" name="sprmTCellLeftColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD61B</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellLeftColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="cellLeftColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cellLeftColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCellLeftColor-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellLeftColor"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellLeftColor--> + <!--SPRM sprmTCellBottomColor--> + <UML:Class xmi.id="sprmTCellBottomColor" name="sprmTCellBottomColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD61C</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellBottomColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="cellBottomColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cellBottomColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCellBottomColor-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellBottomColor"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellBottomColor--> + <!--SPRM sprmTCellRightColor--> + <UML:Class xmi.id="sprmTCellRightColor" name="sprmTCellRightColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD61D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellRightColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="cellRightColor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:cellRightColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCellRightColor-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellRightColor"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellRightColor--> + <!--SPRM sprmTGridLineProps--> + <UML:Class xmi.id="sprmTGridLineProps" name="sprmTGridLineProps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD613</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTGridLineProps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x33</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <!-- + <UML:Operation name="gridLineProps" > + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:gridLineProps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid" /> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return" > + <UML:Parameter.type> + <UML:Class xmi.idref="LineProps" /> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array" /> + </UML:ModelElement.stereotype> + </UML:Operation> + --> + <UML:Attribute name="linePropsTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>top line properties</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSTOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linePropsLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>left line properties</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xb</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linePropsBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>bottom line properties</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x13</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSBOTTOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linePropsRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>right line properties</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1b</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSRIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linePropsHorizontal"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>horizontal line properties</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x23</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSHORIZONTAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="linePropsVertical"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>vertical line properties</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2b</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSVERTICAL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTGridLineProps-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTGridLineProps"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTGridLineProps--> + <!--SPRM sprmCInsrsid--> + <UML:Class xmi.id="sprmCInsrsid" name="sprmCIndrsid"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6816</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:insrsid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCInsrsid--> + <!--SPRM sprmCdelrsid--> + <UML:Class xmi.id="sprmCdelrsid" name="sprmCdelrsid"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6817</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:delrsid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCdelrsid--> + <!--SPRM sprmPTableDepth--> + <UML:Class xmi.id="sprmPTableDepth" name="sprmPTableDepth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6649</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPTableDepth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPTableDepth--> + <!--SPRM sprmTCellShadow--> + <UML:Class xmi.id="sprmTCellShadow" name="sprmTCellShadow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8nocalcsize"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xd670</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellShadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="cellShadow"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:CELLSHADOW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="CellShd"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCellShadow-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellShadow"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellShadow--> + <!--SPRM sprmPBrcTop--> + <UML:Class xmi.id="sprmPBrcTop" name="sprmPBrcTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6424</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="brcTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>BRC of top line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCTOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBrcTop-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBrcTop"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBrcTop--> + <!--SPRM sprmPBrcLeft--> + <UML:Class xmi.id="sprmPBrcLeft" name="sprmPBrcLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6425</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="brcLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>BRC of left line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBrcLeft-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBrcLeft"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBrcLeft--> + <!--SPRM sprmPBrcBottom--> + <UML:Class xmi.id="sprmPBrcBottom" name="sprmPBrcBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6426</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="brcBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>BRC of bottom line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBrcBottom-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBrcBottom"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBrcBottom--> + <!--SPRM sprmPBrcRight--> + <UML:Class xmi.id="sprmPBrcRight" name="sprmPBrcRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6427</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="brcRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>BRC of top line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCRIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBrcRight-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBrcRight"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBrcRight--> + <!--SPRM sprmPBrcBetween--> + <UML:Class xmi.id="sprmPBrcBetween" name="sprmPBrcBetween"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6428</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBrcBetween</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="brcBetween"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>BRC</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:BRCBETWEEN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="BRC"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBrcBetween-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBrcBetween"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBrcBetween--> + <!--SPRM sprmPBorderTop--> + <UML:Class xmi.id="sprmPBorderTop" name="sprmPBorderTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc64e</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBorderTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="linePropsTop"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>properties of top line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSTOP</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBorderTop-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBorderTop"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBorderTop--> + <!--SPRM sprmPBorderLeft--> + <UML:Class xmi.id="sprmPBorderLeft" name="sprmPBorderLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc64f</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBorderLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="linePropsLeft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>properties of left line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSLEFT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBorderLeft-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBorderLeft"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBorderLeft--> + <!--SPRM sprmPBorderBottom--> + <UML:Class xmi.id="sprmPBorderBottom" name="sprmPBorderBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc650</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBorderBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="linePropsBottom"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>properties of bottom line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSBOTTOM</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBorderBottom-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBorderBottom"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBorderBottom--> + <!--SPRM sprmPBorderRight--> + <UML:Class xmi.id="sprmPBorderRight" name="sprmPBorderRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc651</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBorderRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="linePropsRight"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>properties of right line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSRIGHT</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBorderRight-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBorderRight"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBorderRight--> + <!--SPRM sprmPBorderBetween--> + <UML:Class xmi.id="sprmPBorderBetween" name="sprmPBorderBetween"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc652</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBorderBetween</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="linePropsBetween"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>properties of line in between</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPSBETWEEN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmPBorderBetween-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmPBorderBetween"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmPBorderBetween--> + <!--SPRM sprmCBorder--> + <UML:Class xmi.id="sprmCBorder" name="sprmCBorder"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xca72</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPBorderBetween</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="lineProps"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>properties of line in between</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:LINEPROPS</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="LineProps"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmCBorder-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmCBorder"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmCBorder--> + <!--SPRM sprmTTPreferredWidth--> + <UML:Class xmi.id="sprmTTPreferredWidth" name="sprmTTPreferredWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTTPreferredWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf614</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="unit"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="preferredWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>preferred width</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:preferredWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTTPreferredWidth-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTTPreferredWidth"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTTPreferredWidth--> + <!--SPRM sprmTTRLeft--> + <UML:Class xmi.id="sprmTTRLeft" name="sprmTTRLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTTRLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf661</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="unit"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:unit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="trleft"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table indent from left</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:trleft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTTRLeft-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTTRLeft"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTTRLeft--> + <!--SPRM sprmCEastAsianLayout--> + <UML:Class xmi.id="sprmCEastAsianLayout" name="sprmCEastAsianLayout"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCA78</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCEastAsianLayout</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fcEastAsianLayout"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>East Asian Typography Setting</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fcEastAsianLayout</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmCEastAsianLayout-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmCEastAsianLayout"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmCEastAsianLayout--> + <!--SPRM sprmTWidthBefore--> + <UML:Class xmi.id="sprmTWidthBefore" name="sprmTWidthBefore"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xF617</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTWidthBefore</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="ftsWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ftsWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:wWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTWidthBefore-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTWidthBefore"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTWidthBefore--> + <!--SPRM sprmTWidthAfter--> + <UML:Class xmi.id="sprmTWidthAfter" name="sprmTWidthAfter"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xF618</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTWidthAfter</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="ftsWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ftsWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:wWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTWidthAfter-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTWidthAfter"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTWidthAfter--> + <!--SPRM sprmPDxaLeft1--> + <UML:Class xmi.id="sprmPDxaLeft1" name="sprmPDxaLeft1"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8460</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPDxaLeft1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPDxaLeft1--> + <!--SPRM sprmPRsid--> + <UML:Class xmi.id="sprmPRsid" name="sprmPRsid"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6467</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmPRsid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmPRsid--> + <!--SPRM sprmCRsidProp--> + <UML:Class xmi.id="sprmCRsidProp" name="sprmCRsidProp"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6815</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRsidProp</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>paragraph</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRsidProp--> + <!--SPRM sprmCRgLid0--> + <UML:Class xmi.id="sprmCRgLid0" name="sprmCRgLid0"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4873</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmCRgLid0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>character</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmCRgLid0--> + <!--SPRM sprmTCellPaddingDefault--> + <UML:Class xmi.id="sprmTCellPaddingDefault" name="sprmTCellPaddingDefault"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xD634</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTCellPaddingDefault</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="itc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:itc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="grfbrc"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:grfbrc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="ftsWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:ftsWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="wWidth"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:wWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U16"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTCellPaddingDefault-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTCellPaddingDefault"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTCellPaddingDefault--> + <!--SPRM sprmTRsid--> + <UML:Class xmi.id="sprmTRsid" name="sprmTRsid"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x7479</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTRsid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTRsid--> + <!--SPRM sprmTFAutofit--> + <UML:Class xmi.id="sprmTFAutofit" name="sprmTFAutofit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3615</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTFAutofit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTFAutofit--> + <!--SPRM sprmTPc--> + <UML:Class xmi.id="sprmTPc" name="sprmTPc"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x360D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTPc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="padding"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:padding</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pcVert"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xc</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:pcVert</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="pcHorz"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:pcHorz</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U8"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="sprmTPc-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="sprmTPc"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--SPRM sprmTPc--> + <!--SPRM sprmTDyaAbs--> + <UML:Class xmi.id="sprmTDyaAbs" name="sprmTDyaAbs"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x940F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDyaAbs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDyaAbs--> + <!--SPRM sprmTDxaFromText--> + <UML:Class xmi.id="sprmTDxaFromText" name="sprmTDxaFromText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9410</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDxaFromText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDxaFromText--> + <!--SPRM sprmTDyaFromText--> + <UML:Class xmi.id="sprmTDyaFromText" name="sprmTDyaFromText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x9411</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDyaFromText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDyaFromText--> + <!--SPRM sprmTDxaFromTextRight--> + <UML:Class xmi.id="sprmTDxaFromTextRight" name="sprmTDxaFromTextRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x941E</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDxaFromTextRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDxaFromTextRight--> + <!--SPRM sprmTDyaFromTextBottom--> + <UML:Class xmi.id="sprmTDyaFromTextBottom" name="sprmTDyaFromTextBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x941F</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTDyaFromTextBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTDyaFromTextBottom--> + <!--SPRM sprmTFNoAllowOverlap--> + <UML:Class xmi.id="sprmTFNoAllowOverlap" name="sprmTFNoAllowOverlap"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x3465</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmcode"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:sprmTFNoAllowOverlap</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="sprmid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>table</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="kind"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--SPRM sprmTFNoAllowOverlap--> + <!--SPRMS--> + <!--DFFS--> + <!--DFF UDefProp--> + <UML:Class xmi.id="UDefProp" name="UDefProp"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="resolvenoauto"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf122</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="UDefProp-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="UDefProp"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF UDefProp--> + <!--DFF FSPGR--> + <UML:Class xmi.id="FSPGR" name="FSPGR"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf009</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="rectangle"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the rectangle of the grouped shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:rectangle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="Rectangle"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FSPGR-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FSPGR"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF FSPGR--> + <!--DFF OPT--> + <UML:Class xmi.id="OPT" name="OPT"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf00b</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="property"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpopt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="FOPTE"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + <UML:Operation name="extraoffset"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpoptextraoffset</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="U32"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="noresolve"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="OPT-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="OPT"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF OPT--> + <!--DFF FSP--> + <UML:Class xmi.id="FSP" name="FSP"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf00a</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="shptype"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>shape type</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xfff0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shptype</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="shptypename"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shptypename</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpid"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>shape id</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfGroup"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>This shape is a group shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfGroup</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfChild"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Not a top-level shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfChild</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfPatriarch"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>This is the topmost group shape. Exactly one of these per drawing.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>2</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfPatriarch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfDeleted"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The shape has been deleted</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfDeleted</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfOleShape"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The shape is an OLE object</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfOleShape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfHaveMaster"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape has a hspMaster property</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfHaveMaster</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfFlipH"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape is flipped horizontally</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x40</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>6</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfFlipH</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfFlipV"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape is flipped vertically</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x80</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>7</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfFlipV</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfConnector"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Connector type of shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x100</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfConnector</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfHaveAnchor"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape has an anchor of some kind</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x200</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfHaveAnchor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfBackground"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Background shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfBackground</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="shpfHaveSpt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape has a shape type property</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x800</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>11</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfHaveSpt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Attribute name="reserved"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Not yet used</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x0c</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>20</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xfffff000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:reserved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="U32"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="FSP-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="FSP"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF FSP--> + <!--DFF DGG--> + <UML:Class xmi.id="DGG" name="DGG"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf006</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fdgg"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the dgg structure</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpdgg</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="FDGG"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="fidcl"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpdgg</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="FIDCL"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="DGG-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="DGG"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF DGG--> + <!--DFF BSE--> + <UML:Class xmi.id="BSE" name="BSE"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf007</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fbse"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the FBSE structure</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpfbse</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="FBSE"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="blipname"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shpblipbname</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="String"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature><UML:Operation name="blip"><UML:ModelElement.taggedValue><UML:TaggedValue><UML:TaggedValue.dataValue>rtf:blip</UML:TaggedValue.dataValue><UML:TaggedValue.type><UML:TagDefinition xmi.idref="opid"/></UML:TaggedValue.type></UML:TaggedValue></UML:ModelElement.taggedValue><UML:BehavioralFeature.parameter><UML:Parameter kind="return" name="return"><UML:Parameter.type><UML:Class xmi.idref="DffRecord"/></UML:Parameter.type></UML:Parameter></UML:BehavioralFeature.parameter><UML:ModelElement.stereotype><UML:Stereotype xmi.idref="attribute"/></UML:ModelElement.stereotype></UML:Operation> + g </UML:Classifier.feature> + <!-- + <UML:Classifier.feature> + <UML:Operation name="binary"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:binary</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="Binary"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="binary"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + --> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="BSE-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="BSE"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF BSE--> + <!--DFF BlipPng--> + <UML:Class xmi.id="BlipPng" name="BlipPng"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf01e</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="payload"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the actual PNG</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x19</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:payload</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="Blob"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attributeremainder"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="BlipPng-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="BlipPng"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF BlipPng--> + <!--DFF BlipDib--> + <UML:Class xmi.id="BlipDib" name="BlipDib"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf01f</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="payload"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>the actual DIB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x19</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:payload</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="Blob"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attributeremainder"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="BlipDib-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="BlipDib"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF BlipDib--> + <!--DFF SpContainer--> + <UML:Class xmi.id="SpContainer" name="SpContainer"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf004</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Operation name="blip"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:blip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="BSE"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + <UML:Classifier.feature> + <UML:Operation name="shptxt"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:shptxt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="opid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class xmi.idref="TextboxText"/> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Operation> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="SpContainer-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="SpContainer"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF SpContainer--> + <!--DFF Dg--> + <UML:Class xmi.id="Dg" name="Dg"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffrecord"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xf008</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="dffid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:Classifier.feature> + <UML:Attribute name="fdg"> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The FDG data structure</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>64</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rtf:fdg</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType xmi.idref="FDG"/> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </UML:Class> + <UML:Generalization isSpecification="false" xmi.id="Dg-Properties"> + <UML:Generalization.child> + <UML:Class xmi.idref="Dg"/> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"/> + </UML:Generalization.parent> + </UML:Generalization> + <!--DFF Dg--> + <!--DFFS--> + <!--DFFOPT--> + <!--DFFOPT rotation--> + <UML:Class xmi.id="rotation" name="rotation"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shprotation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>4</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>fixed point: 16.16 + degrees</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT rotation--> + <!--DFFOPT fLockRotation--> + <UML:Class xmi.id="fLockRotation" name="fLockRotation"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockRotation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>119</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>No rotation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockRotation--> + <!--DFFOPT fLockAspectRatio--> + <UML:Class xmi.id="fLockAspectRatio" name="fLockAspectRatio"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockAspectRatio</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>120</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Don't allow changes in + aspect ratio</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockAspectRatio--> + <!--DFFOPT fLockPosition--> + <UML:Class xmi.id="fLockPosition" name="fLockPosition"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockPosition</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>121</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Don't allow the shape to + be moved</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockPosition--> + <!--DFFOPT fLockAgainstSelect--> + <UML:Class xmi.id="fLockAgainstSelect" name="fLockAgainstSelect"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockAgainstSelect</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>122</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape may not be + selected</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockAgainstSelect--> + <!--DFFOPT fLockCropping--> + <UML:Class xmi.id="fLockCropping" name="fLockCropping"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockCropping</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>123</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>No cropping this + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockCropping--> + <!--DFFOPT fLockVertices--> + <UML:Class xmi.id="fLockVertices" name="fLockVertices"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockVertices</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>124</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Edit Points not + allowed</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockVertices--> + <!--DFFOPT fLockText--> + <UML:Class xmi.id="fLockText" name="fLockText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>125</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Do not edit + text</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockText--> + <!--DFFOPT fLockAdjustHandles--> + <UML:Class xmi.id="fLockAdjustHandles" name="fLockAdjustHandles"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockAdjustHandles</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>126</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Do not adjust</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockAdjustHandles--> + <!--DFFOPT fLockAgainstGrouping--> + <UML:Class xmi.id="fLockAgainstGrouping" name="fLockAgainstGrouping"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockAgainstGrouping</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>127</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Do not group this + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockAgainstGrouping--> + <!--DFFOPT lTxid--> + <UML:Class xmi.id="lTxid" name="lTxid"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplTxid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>128</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>id for the text, value + determined by the host</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lTxid--> + <!--DFFOPT dxTextLeft--> + <UML:Class xmi.id="dxTextLeft" name="dxTextLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxTextLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>129</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/10 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>margins relative to + shape's inscribed text rectangle (in EMUs)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxTextLeft--> + <!--DFFOPT dyTextTop--> + <UML:Class xmi.id="dyTextTop" name="dyTextTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdyTextTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>130</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/20 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dyTextTop--> + <!--DFFOPT dxTextRight--> + <UML:Class xmi.id="dxTextRight" name="dxTextRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxTextRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>131</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/10 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxTextRight--> + <!--DFFOPT dyTextBottom--> + <UML:Class xmi.id="dyTextBottom" name="dyTextBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdyTextBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>132</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/20 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dyTextBottom--> + <!--DFFOPT WrapText--> + <UML:Class xmi.id="WrapText" name="WrapText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpWrapText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>133</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Wrap text at shape + margins</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT WrapText--> + <!--DFFOPT scaleText--> + <UML:Class xmi.id="scaleText" name="scaleText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpscaleText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>134</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Text zoom/scale (used if + fFitTextToShape)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT scaleText--> + <!--DFFOPT anchorText--> + <UML:Class xmi.id="anchorText" name="anchorText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpanchorText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>135</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Top</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How to anchor the + text</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT anchorText--> + <!--DFFOPT txflTextFlow--> + <UML:Class xmi.id="txflTextFlow" name="txflTextFlow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shptxflTextFlow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>136</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>HorzN</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Text flow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT txflTextFlow--> + <!--DFFOPT cdirFont--> + <UML:Class xmi.id="cdirFont" name="cdirFont"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpcdirFont</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>137</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>msocdir0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Font rotation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT cdirFont--> + <!--DFFOPT hspNext--> + <UML:Class xmi.id="hspNext" name="hspNext"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shphspNext</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>138</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>ID of the next shape + (used by Word for linked textboxes)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT hspNext--> + <!--DFFOPT txdir--> + <UML:Class xmi.id="txdir" name="txdir"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shptxdir</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>139</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>LTR</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Bi-Di Text + direction</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT txdir--> + <!--DFFOPT fSelectText--> + <UML:Class xmi.id="fSelectText" name="fSelectText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfSelectText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>187</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE if single click + selects text, FALSE if two clicks</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fSelectText--> + <!--DFFOPT fAutoTextMargin--> + <UML:Class xmi.id="fAutoTextMargin" name="fAutoTextMargin"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfAutoTextMargin</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>188</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>use host's margin + calculations</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fAutoTextMargin--> + <!--DFFOPT fRotateText--> + <UML:Class xmi.id="fRotateText" name="fRotateText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfRotateText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>189</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Rotate text with + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fRotateText--> + <!--DFFOPT fFitShapeToText--> + <UML:Class xmi.id="fFitShapeToText" name="fFitShapeToText"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfFitShapeToText</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>190</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Size shape to fit text + size</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fFitShapeToText--> + <!--DFFOPT fFitTextToShape--> + <UML:Class xmi.id="fFitTextToShape" name="fFitTextToShape"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfFitTextToShape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>191</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Size text to fit shape + size</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fFitTextToShape--> + <!--DFFOPT gtextUNICODE--> + <UML:Class xmi.id="gtextUNICODE" name="gtextUNICODE"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextUNICODE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>192</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>UNICODE text + string</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextUNICODE--> + <!--DFFOPT gtextRTF--> + <UML:Class xmi.id="gtextRTF" name="gtextRTF"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextRTF</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>193</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>RTF text + string</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextRTF--> + <!--DFFOPT gtextAlign--> + <UML:Class xmi.id="gtextAlign" name="gtextAlign"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextAlign</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>194</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Center</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>alignment on + curve</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextAlign--> + <!--DFFOPT gtextSize--> + <UML:Class xmi.id="gtextSize" name="gtextSize"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextSize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>195</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>36<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>default point + size</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextSize--> + <!--DFFOPT gtextSpacing--> + <UML:Class xmi.id="gtextSpacing" name="gtextSpacing"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextSpacing</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>196</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>fixed point + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextSpacing--> + <!--DFFOPT gtextFont--> + <UML:Class xmi.id="gtextFont" name="gtextFont"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFont</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>197</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>font family + name</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFont--> + <!--DFFOPT gtextFReverseRows--> + <UML:Class xmi.id="gtextFReverseRows" name="gtextFReverseRows"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFReverseRows</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>240</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Reverse row + order</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFReverseRows--> + <!--DFFOPT fGtext--> + <UML:Class xmi.id="fGtext" name="fGtext"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfGtext</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>241</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Has text + effect</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fGtext--> + <!--DFFOPT gtextFVertical--> + <UML:Class xmi.id="gtextFVertical" name="gtextFVertical"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFVertical</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>242</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Rotate + characters</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFVertical--> + <!--DFFOPT gtextFKern--> + <UML:Class xmi.id="gtextFKern" name="gtextFKern"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFKern</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>243</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Kern + characters</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFKern--> + <!--DFFOPT gtextFTight--> + <UML:Class xmi.id="gtextFTight" name="gtextFTight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFTight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>244</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Tightening or + tracking</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFTight--> + <!--DFFOPT gtextFStretch--> + <UML:Class xmi.id="gtextFStretch" name="gtextFStretch"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFStretch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>245</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Stretch to fit + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFStretch--> + <!--DFFOPT gtextFShrinkFit--> + <UML:Class xmi.id="gtextFShrinkFit" name="gtextFShrinkFit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFShrinkFit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>246</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Char bounding + box</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFShrinkFit--> + <!--DFFOPT gtextFBestFit--> + <UML:Class xmi.id="gtextFBestFit" name="gtextFBestFit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFBestFit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>247</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Scale + text-on-path</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFBestFit--> + <!--DFFOPT gtextFNormalize--> + <UML:Class xmi.id="gtextFNormalize" name="gtextFNormalize"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFNormalize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>248</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Stretch char + height</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFNormalize--> + <!--DFFOPT gtextFDxMeasure--> + <UML:Class xmi.id="gtextFDxMeasure" name="gtextFDxMeasure"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFDxMeasure</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>249</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Do not measure along + path</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFDxMeasure--> + <!--DFFOPT gtextFBold--> + <UML:Class xmi.id="gtextFBold" name="gtextFBold"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFBold</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>250</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Bold font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFBold--> + <!--DFFOPT gtextFItalic--> + <UML:Class xmi.id="gtextFItalic" name="gtextFItalic"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFItalic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>251</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Italic font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFItalic--> + <!--DFFOPT gtextFUnderline--> + <UML:Class xmi.id="gtextFUnderline" name="gtextFUnderline"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFUnderline</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>252</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Underline + font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFUnderline--> + <!--DFFOPT gtextFShadow--> + <UML:Class xmi.id="gtextFShadow" name="gtextFShadow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFShadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>253</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shadow font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFShadow--> + <!--DFFOPT gtextFSmallcaps--> + <UML:Class xmi.id="gtextFSmallcaps" name="gtextFSmallcaps"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFSmallcaps</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>254</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Small caps + font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFSmallcaps--> + <!--DFFOPT gtextFStrikethrough--> + <UML:Class xmi.id="gtextFStrikethrough" name="gtextFStrikethrough"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgtextFStrikethrough</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>255</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Strike through + font</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT gtextFStrikethrough--> + <!--DFFOPT cropFromTop--> + <UML:Class xmi.id="cropFromTop" name="cropFromTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpcropFromTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>256</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16 + fraction times total image width or height, as + appropriate.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT cropFromTop--> + <!--DFFOPT cropFromBottom--> + <UML:Class xmi.id="cropFromBottom" name="cropFromBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpcropFromBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>257</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT cropFromBottom--> + <!--DFFOPT cropFromLeft--> + <UML:Class xmi.id="cropFromLeft" name="cropFromLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpcropFromLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>258</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT cropFromLeft--> + <!--DFFOPT cropFromRight--> + <UML:Class xmi.id="cropFromRight" name="cropFromRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpcropFromRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>259</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT cropFromRight--> + <!--DFFOPT pib--> + <UML:Class xmi.id="pib" name="pib"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppib</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>260</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip to + display</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pib--> + <!--DFFOPT pibName--> + <UML:Class xmi.id="pibName" name="pibName"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppibName</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>261</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip file + name</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pibName--> + <!--DFFOPT pibFlags--> + <UML:Class xmi.id="pibFlags" name="pibFlags"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppibFlags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>262</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Comment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip + flags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pibFlags--> + <!--DFFOPT pictureTransparent--> + <UML:Class xmi.id="pictureTransparent" name="pictureTransparent"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureTransparent</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>263</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>~0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>transparent + color (none if ~0UL)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureTransparent--> + <!--DFFOPT pictureContrast--> + <UML:Class xmi.id="pictureContrast" name="pictureContrast"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureContrast</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>264</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>contrast + setting</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureContrast--> + <!--DFFOPT pictureBrightness--> + <UML:Class xmi.id="pictureBrightness" name="pictureBrightness"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureBrightness</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>265</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>brightness + setting</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureBrightness--> + <!--DFFOPT pictureGamma--> + <UML:Class xmi.id="pictureGamma" name="pictureGamma"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureGamma</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>266</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16 + gamma</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureGamma--> + <!--DFFOPT pictureId--> + <UML:Class xmi.id="pictureId" name="pictureId"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureId</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>267</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Host-defined + ID for OLE objects (usually a pointer)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureId--> + <!--DFFOPT pictureDblCrMod--> + <UML:Class xmi.id="pictureDblCrMod" name="pictureDblCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureDblCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>268</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>This</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Modification + used if shape has double shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureDblCrMod--> + <!--DFFOPT pictureFillCrMod--> + <UML:Class xmi.id="pictureFillCrMod" name="pictureFillCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureFillCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>269</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undefined</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureFillCrMod--> + <!--DFFOPT pictureLineCrMod--> + <UML:Class xmi.id="pictureLineCrMod" name="pictureLineCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureLineCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>270</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undefined</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureLineCrMod--> + <!--DFFOPT pibPrint--> + <UML:Class xmi.id="pibPrint" name="pibPrint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppibPrint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>271</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip to + display when printing</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pibPrint--> + <!--DFFOPT pibPrintName--> + <UML:Class xmi.id="pibPrintName" name="pibPrintName"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppibPrintName</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>272</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip file + name</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pibPrintName--> + <!--DFFOPT pibPrintFlags--> + <UML:Class xmi.id="pibPrintFlags" name="pibPrintFlags"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppibPrintFlags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>273</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Comment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip + flags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pibPrintFlags--> + <!--DFFOPT fNoHitTestPicture--> + <UML:Class xmi.id="fNoHitTestPicture" name="fNoHitTestPicture"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfNoHitTestPicture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>316</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Do not hit + test the picture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fNoHitTestPicture--> + <!--DFFOPT pictureGray--> + <UML:Class xmi.id="pictureGray" name="pictureGray"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureGray</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>317</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>grayscale + display</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureGray--> + <!--DFFOPT pictureBiLevel--> + <UML:Class xmi.id="pictureBiLevel" name="pictureBiLevel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureBiLevel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>318</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>bi-level + display</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureBiLevel--> + <!--DFFOPT pictureActive--> + <UML:Class xmi.id="pictureActive" name="pictureActive"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppictureActive</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>319</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Server is + active (OLE objects only)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pictureActive--> + <!--DFFOPT geoLeft--> + <UML:Class xmi.id="geoLeft" name="geoLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgeoLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>320</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Defines the G (geometry) + coordinate space.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT geoLeft--> + <!--DFFOPT geoTop--> + <UML:Class xmi.id="geoTop" name="geoTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgeoTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>321</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT geoTop--> + <!--DFFOPT geoRight--> + <UML:Class xmi.id="geoRight" name="geoRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgeoRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>322</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>21600</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT geoRight--> + <!--DFFOPT geoBottom--> + <UML:Class xmi.id="geoBottom" name="geoBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpgeoBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>323</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>21600</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT geoBottom--> + <!--DFFOPT shapePath--> + <UML:Class xmi.id="shapePath" name="shapePath"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshapePath</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>324</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>msoshapeLinesClosed</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shapePath--> + <!--DFFOPT pVertices--> + <UML:Class xmi.id="pVertices" name="pVertices"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppVertices</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>325</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>An array of points, in G + units.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pVertices--> + <!--DFFOPT pSegmentInfo--> + <UML:Class xmi.id="pSegmentInfo" name="pSegmentInfo"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppSegmentInfo</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>326</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pSegmentInfo--> + <!--DFFOPT adjustValue--> + <UML:Class xmi.id="adjustValue" name="adjustValue"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjustValue</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>327</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Adjustment values + corresponding to the positions of the adjust handles of the shape. + The number of values used and their allowable ranges vary from + shape type to shape type.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjustValue--> + <!--DFFOPT adjust2Value--> + <UML:Class xmi.id="adjust2Value" name="adjust2Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust2Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>328</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust2Value--> + <!--DFFOPT adjust3Value--> + <UML:Class xmi.id="adjust3Value" name="adjust3Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust3Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>329</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust3Value--> + <!--DFFOPT adjust4Value--> + <UML:Class xmi.id="adjust4Value" name="adjust4Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust4Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>330</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust4Value--> + <!--DFFOPT adjust5Value--> + <UML:Class xmi.id="adjust5Value" name="adjust5Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust5Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>331</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust5Value--> + <!--DFFOPT adjust6Value--> + <UML:Class xmi.id="adjust6Value" name="adjust6Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust6Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>332</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust6Value--> + <!--DFFOPT adjust7Value--> + <UML:Class xmi.id="adjust7Value" name="adjust7Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust7Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>333</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust7Value--> + <!--DFFOPT adjust8Value--> + <UML:Class xmi.id="adjust8Value" name="adjust8Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust8Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>334</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust8Value--> + <!--DFFOPT adjust9Value--> + <UML:Class xmi.id="adjust9Value" name="adjust9Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust9Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>335</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust9Value--> + <!--DFFOPT adjust10Value--> + <UML:Class xmi.id="adjust10Value" name="adjust10Value"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpadjust10Value</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>336</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT adjust10Value--> + <!--DFFOPT fShadowOK--> + <UML:Class xmi.id="fShadowOK" name="fShadowOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfShadowOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>378</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shadow may be + set</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fShadowOK--> + <!--DFFOPT f3DOK--> + <UML:Class xmi.id="f3DOK" name="f3DOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpf3DOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>379</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>3D may be set</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT f3DOK--> + <!--DFFOPT fLineOK--> + <UML:Class xmi.id="fLineOK" name="fLineOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLineOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>380</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Line style may be + set</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLineOK--> + <!--DFFOPT fGtextOK--> + <UML:Class xmi.id="fGtextOK" name="fGtextOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfGtextOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>381</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Text effect (WordArt) + supported</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fGtextOK--> + <!--DFFOPT fFillShadeShapeOK--> + <UML:Class xmi.id="fFillShadeShapeOK" name="fFillShadeShapeOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfFillShadeShapeOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>382</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fFillShadeShapeOK--> + <!--DFFOPT fFillOK--> + <UML:Class xmi.id="fFillOK" name="fFillOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfFillOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>383</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>OK to fill the shape + through the UI or VBA?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fFillOK--> + <!--DFFOPT fillType--> + <UML:Class xmi.id="fillType" name="fillType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>384</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Solid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Type of + fill</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillType--> + <!--DFFOPT fillColor--> + <UML:Class xmi.id="fillColor" name="fillColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>385</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>white</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Foreground + color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillColor--> + <!--DFFOPT fillOpacity--> + <UML:Class xmi.id="fillOpacity" name="fillOpacity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillOpacity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>386</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillOpacity--> + <!--DFFOPT fillBackColor--> + <UML:Class xmi.id="fillBackColor" name="fillBackColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillBackColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>387</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>white</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Background + color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillBackColor--> + <!--DFFOPT fillBackOpacity--> + <UML:Class xmi.id="fillBackOpacity" name="fillBackOpacity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillBackOpacity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>388</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shades + only</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillBackOpacity--> + <!--DFFOPT fillCrMod--> + <UML:Class xmi.id="fillCrMod" name="fillCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>389</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undefined</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Modification + for BW views</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillCrMod--> + <!--DFFOPT fillBlip--> + <UML:Class xmi.id="fillBlip" name="fillBlip"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillBlip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>390</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Pattern/texture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillBlip--> + <!--DFFOPT fillBlipName--> + <UML:Class xmi.id="fillBlipName" name="fillBlipName"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillBlipName</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>391</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip file + name</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillBlipName--> + <!--DFFOPT fillBlipFlags--> + <UML:Class xmi.id="fillBlipFlags" name="fillBlipFlags"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillBlipFlags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>392</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Comment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip + flags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillBlipFlags--> + <!--DFFOPT fillWidth--> + <UML:Class xmi.id="fillWidth" name="fillWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>393</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How big (A + units) to make a metafile texture.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillWidth--> + <!--DFFOPT fillHeight--> + <UML:Class xmi.id="fillHeight" name="fillHeight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillHeight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>394</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillHeight--> + <!--DFFOPT fillAngle--> + <UML:Class xmi.id="fillAngle" name="fillAngle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillAngle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>395</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fade angle - + degrees in 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillAngle--> + <!--DFFOPT fillFocus--> + <UML:Class xmi.id="fillFocus" name="fillFocus"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillFocus</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>396</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Linear shaded + fill focus percent</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillFocus--> + <!--DFFOPT fillToLeft--> + <UML:Class xmi.id="fillToLeft" name="fillToLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillToLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>397</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fraction + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillToLeft--> + <!--DFFOPT fillToTop--> + <UML:Class xmi.id="fillToTop" name="fillToTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillToTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>398</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fraction + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillToTop--> + <!--DFFOPT fillToRight--> + <UML:Class xmi.id="fillToRight" name="fillToRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillToRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>399</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fraction + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillToRight--> + <!--DFFOPT fillToBottom--> + <UML:Class xmi.id="fillToBottom" name="fillToBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillToBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fraction + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillToBottom--> + <!--DFFOPT fillRectLeft--> + <UML:Class xmi.id="fillRectLeft" name="fillRectLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillRectLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>401</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>For shaded + fills, use the specified rectangle instead of the shape's bounding + rect to define how large the fade is going to be.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillRectLeft--> + <!--DFFOPT fillRectTop--> + <UML:Class xmi.id="fillRectTop" name="fillRectTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillRectTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>402</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillRectTop--> + <!--DFFOPT fillRectRight--> + <UML:Class xmi.id="fillRectRight" name="fillRectRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillRectRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>403</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillRectRight--> + <!--DFFOPT fillRectBottom--> + <UML:Class xmi.id="fillRectBottom" name="fillRectBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillRectBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>404</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillRectBottom--> + <!--DFFOPT fillDztype--> + <UML:Class xmi.id="fillDztype" name="fillDztype"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillDztype</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>405</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Default</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillDztype--> + <!--DFFOPT fillShadePreset--> + <UML:Class xmi.id="fillShadePreset" name="fillShadePreset"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillShadePreset</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>406</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Special + shades</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillShadePreset--> + <!--DFFOPT fillShadeColors--> + <UML:Class xmi.id="fillShadeColors" name="fillShadeColors"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillShadeColors</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>407</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>a preset + array of colors</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillShadeColors--> + <!--DFFOPT fillOriginX--> + <UML:Class xmi.id="fillOriginX" name="fillOriginX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillOriginX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>408</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillOriginX--> + <!--DFFOPT fillOriginY--> + <UML:Class xmi.id="fillOriginY" name="fillOriginY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillOriginY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>409</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillOriginY--> + <!--DFFOPT fillShapeOriginX--> + <UML:Class xmi.id="fillShapeOriginX" name="fillShapeOriginX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillShapeOriginX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>410</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillShapeOriginX--> + <!--DFFOPT fillShapeOriginY--> + <UML:Class xmi.id="fillShapeOriginY" name="fillShapeOriginY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillShapeOriginY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>411</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillShapeOriginY--> + <!--DFFOPT fillShadeType--> + <UML:Class xmi.id="fillShadeType" name="fillShadeType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillShadeType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>412</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Default</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Type of + shading, if a shaded (gradient) fill.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillShadeType--> + <!--DFFOPT fFilled--> + <UML:Class xmi.id="fFilled" name="fFilled"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfFilled</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>443</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Is shape + filled?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fFilled--> + <!--DFFOPT fHitTestFill--> + <UML:Class xmi.id="fHitTestFill" name="fHitTestFill"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfHitTestFill</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>444</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Should we hit + test fill?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fHitTestFill--> + <!--DFFOPT fillShape--> + <UML:Class xmi.id="fillShape" name="fillShape"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillShape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>445</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Register + pattern on shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillShape--> + <!--DFFOPT fillUseRect--> + <UML:Class xmi.id="fillUseRect" name="fillUseRect"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfillUseRect</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>446</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Use the large + rect?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fillUseRect--> + <!--DFFOPT fNoFillHitTest--> + <UML:Class xmi.id="fNoFillHitTest" name="fNoFillHitTest"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfNoFillHitTest</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>447</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Hit test a + shape as though filled</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fNoFillHitTest--> + <!--DFFOPT lineColor--> + <UML:Class xmi.id="lineColor" name="lineColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>448</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>black</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Color of line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineColor--> + <!--DFFOPT lineOpacity--> + <UML:Class xmi.id="lineOpacity" name="lineOpacity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineOpacity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>449</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Not + implemented</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineOpacity--> + <!--DFFOPT lineBackColor--> + <UML:Class xmi.id="lineBackColor" name="lineBackColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineBackColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>450</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>white</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Background + color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineBackColor--> + <!--DFFOPT lineCrMod--> + <UML:Class xmi.id="lineCrMod" name="lineCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>451</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undefined</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Modification for BW + views</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineCrMod--> + <!--DFFOPT lineType--> + <UML:Class xmi.id="lineType" name="lineType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>452</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Solid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Type of line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineType--> + <!--DFFOPT lineFillBlip--> + <UML:Class xmi.id="lineFillBlip" name="lineFillBlip"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillBlip</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>453</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Pattern/texture</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillBlip--> + <!--DFFOPT lineFillBlipName--> + <UML:Class xmi.id="lineFillBlipName" name="lineFillBlipName"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillBlipName</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>454</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip file + name</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillBlipName--> + <!--DFFOPT lineFillBlipFlags--> + <UML:Class xmi.id="lineFillBlipFlags" name="lineFillBlipFlags"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillBlipFlags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>455</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Comment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Blip flags</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillBlipFlags--> + <!--DFFOPT lineFillWidth--> + <UML:Class xmi.id="lineFillWidth" name="lineFillWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>456</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How big (A units) to make + a metafile texture.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillWidth--> + <!--DFFOPT lineFillHeight--> + <UML:Class xmi.id="lineFillHeight" name="lineFillHeight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillHeight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>457</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillHeight--> + <!--DFFOPT lineFillDztype--> + <UML:Class xmi.id="lineFillDztype" name="lineFillDztype"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillDztype</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>458</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Default</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How to interpret + fillWidth/Height numbers.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillDztype--> + <!--DFFOPT lineWidth--> + <UML:Class xmi.id="lineWidth" name="lineWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>459</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9525</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>A units; 1pt == 12700 + EMUs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineWidth--> + <!--DFFOPT lineMiterLimit--> + <UML:Class xmi.id="lineMiterLimit" name="lineMiterLimit"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineMiterLimit</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>460</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>8<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>ratio (16.16) of + width</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineMiterLimit--> + <!--DFFOPT lineStyle--> + <UML:Class xmi.id="lineStyle" name="lineStyle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineStyle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>461</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Simple</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Draw parallel + lines?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineStyle--> + <!--DFFOPT lineDashing--> + <UML:Class xmi.id="lineDashing" name="lineDashing"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineDashing</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>462</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Solid</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Can be overridden + by:</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineDashing--> + <!--DFFOPT lineDashStyle--> + <UML:Class xmi.id="lineDashStyle" name="lineDashStyle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineDashStyle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>463</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>As Win32 + ExtCreatePen</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineDashStyle--> + <!--DFFOPT lineStartArrowhead--> + <UML:Class xmi.id="lineStartArrowhead" name="lineStartArrowhead"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineStartArrowhead</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>464</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NoEnd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Arrow at + start</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineStartArrowhead--> + <!--DFFOPT lineEndArrowhead--> + <UML:Class xmi.id="lineEndArrowhead" name="lineEndArrowhead"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineEndArrowhead</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>465</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NoEnd</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Arrow at end</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineEndArrowhead--> + <!--DFFOPT lineStartArrowWidth--> + <UML:Class xmi.id="lineStartArrowWidth" name="lineStartArrowWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineStartArrowWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>466</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>MediumWidthArrow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Arrow at + start</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineStartArrowWidth--> + <!--DFFOPT lineStartArrowLength--> + <UML:Class xmi.id="lineStartArrowLength" name="lineStartArrowLength"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineStartArrowLength</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>467</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>MediumLenArrow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Arrow at end</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineStartArrowLength--> + <!--DFFOPT lineEndArrowWidth--> + <UML:Class xmi.id="lineEndArrowWidth" name="lineEndArrowWidth"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineEndArrowWidth</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>468</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>MediumWidthArrow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Arrow at + start</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineEndArrowWidth--> + <!--DFFOPT lineEndArrowLength--> + <UML:Class xmi.id="lineEndArrowLength" name="lineEndArrowLength"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineEndArrowLength</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>469</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>MediumLenArrow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Arrow at end</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineEndArrowLength--> + <!--DFFOPT lineJoinStyle--> + <UML:Class xmi.id="lineJoinStyle" name="lineJoinStyle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineJoinStyle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>470</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>JoinRound</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How to join + lines</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineJoinStyle--> + <!--DFFOPT lineEndCapStyle--> + <UML:Class xmi.id="lineEndCapStyle" name="lineEndCapStyle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineEndCapStyle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>471</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>EndCapFlat</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>How to end + lines</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineEndCapStyle--> + <!--DFFOPT fArrowheadsOK--> + <UML:Class xmi.id="fArrowheadsOK" name="fArrowheadsOK"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfArrowheadsOK</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>507</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Allow arrowheads if prop. + is set</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fArrowheadsOK--> + <!--DFFOPT fLine--> + <UML:Class xmi.id="fLine" name="fLine"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLine</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>508</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Any line?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLine--> + <!--DFFOPT fHitTestLine--> + <UML:Class xmi.id="fHitTestLine" name="fHitTestLine"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfHitTestLine</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>509</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Should we hit test + lines?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fHitTestLine--> + <!--DFFOPT lineFillShape--> + <UML:Class xmi.id="lineFillShape" name="lineFillShape"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplineFillShape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>510</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Register pattern on + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lineFillShape--> + <!--DFFOPT fNoLineDrawDash--> + <UML:Class xmi.id="fNoLineDrawDash" name="fNoLineDrawDash"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfNoLineDrawDash</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>511</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Draw a dashed line if no + line</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fNoLineDrawDash--> + <!--DFFOPT shadowType--> + <UML:Class xmi.id="shadowType" name="shadowType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>512</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Offset</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Type of + effect</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowType--> + <!--DFFOPT shadowColor--> + <UML:Class xmi.id="shadowColor" name="shadowColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>513</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0x808080</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Foreground + color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowColor--> + <!--DFFOPT shadowHighlight--> + <UML:Class xmi.id="shadowHighlight" name="shadowHighlight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowHighlight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>514</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0xCBCBCB</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Embossed + color</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowHighlight--> + <!--DFFOPT shadowCrMod--> + <UML:Class xmi.id="shadowCrMod" name="shadowCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>515</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undefined</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Modification for BW + views</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowCrMod--> + <!--DFFOPT shadowOpacity--> + <UML:Class xmi.id="shadowOpacity" name="shadowOpacity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowOpacity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>516</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowOpacity--> + <!--DFFOPT shadowOffsetX--> + <UML:Class xmi.id="shadowOffsetX" name="shadowOffsetX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowOffsetX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>517</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>25400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Offset shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowOffsetX--> + <!--DFFOPT shadowOffsetY--> + <UML:Class xmi.id="shadowOffsetY" name="shadowOffsetY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowOffsetY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>518</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>25400</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Offset shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowOffsetY--> + <!--DFFOPT shadowSecondOffsetX--> + <UML:Class xmi.id="shadowSecondOffsetX" name="shadowSecondOffsetX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowSecondOffsetX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>519</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Double offset + shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowSecondOffsetX--> + <!--DFFOPT shadowSecondOffsetY--> + <UML:Class xmi.id="shadowSecondOffsetY" name="shadowSecondOffsetY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowSecondOffsetY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>520</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Double offset + shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowSecondOffsetY--> + <!--DFFOPT shadowScaleXToX--> + <UML:Class xmi.id="shadowScaleXToX" name="shadowScaleXToX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowScaleXToX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>521</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowScaleXToX--> + <!--DFFOPT shadowScaleYToX--> + <UML:Class xmi.id="shadowScaleYToX" name="shadowScaleYToX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowScaleYToX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>522</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowScaleYToX--> + <!--DFFOPT shadowScaleXToY--> + <UML:Class xmi.id="shadowScaleXToY" name="shadowScaleXToY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowScaleXToY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>523</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowScaleXToY--> + <!--DFFOPT shadowScaleYToY--> + <UML:Class xmi.id="shadowScaleYToY" name="shadowScaleYToY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowScaleYToY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>524</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowScaleYToY--> + <!--DFFOPT shadowPerspectiveX--> + <UML:Class xmi.id="shadowPerspectiveX" name="shadowPerspectiveX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowPerspectiveX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>525</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16 / + weight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowPerspectiveX--> + <!--DFFOPT shadowPerspectiveY--> + <UML:Class xmi.id="shadowPerspectiveY" name="shadowPerspectiveY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowPerspectiveY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>526</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>16.16 / + weight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowPerspectiveY--> + <!--DFFOPT shadowWeight--> + <UML:Class xmi.id="shadowWeight" name="shadowWeight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowWeight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>527</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>scaling + factor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowWeight--> + <!--DFFOPT shadowOriginX--> + <UML:Class xmi.id="shadowOriginX" name="shadowOriginX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowOriginX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>528</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowOriginX--> + <!--DFFOPT shadowOriginY--> + <UML:Class xmi.id="shadowOriginY" name="shadowOriginY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpshadowOriginY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>529</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT shadowOriginY--> + <!--DFFOPT fShadow--> + <UML:Class xmi.id="fShadow" name="fShadow"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfShadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>574</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Any shadow?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fShadow--> + <!--DFFOPT fshadowObscured--> + <UML:Class xmi.id="fshadowObscured" name="fshadowObscured"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfshadowObscured</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>575</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Excel5-style + shadow</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fshadowObscured--> + <!--DFFOPT perspectiveType--> + <UML:Class xmi.id="perspectiveType" name="perspectiveType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>576</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Where transform + applies</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveType--> + <!--DFFOPT perspectiveOffsetX--> + <UML:Class xmi.id="perspectiveOffsetX" name="perspectiveOffsetX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveOffsetX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>577</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The LONG values define a + transformation matrix, effectively, each value is scaled by the + perspectiveWeight parameter.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveOffsetX--> + <!--DFFOPT perspectiveOffsetY--> + <UML:Class xmi.id="perspectiveOffsetY" name="perspectiveOffsetY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveOffsetY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>578</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveOffsetY--> + <!--DFFOPT perspectiveScaleXToX--> + <UML:Class xmi.id="perspectiveScaleXToX" name="perspectiveScaleXToX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveScaleXToX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>579</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveScaleXToX--> + <!--DFFOPT perspectiveScaleYToX--> + <UML:Class xmi.id="perspectiveScaleYToX" name="perspectiveScaleYToX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveScaleYToX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>580</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveScaleYToX--> + <!--DFFOPT perspectiveScaleXToY--> + <UML:Class xmi.id="perspectiveScaleXToY" name="perspectiveScaleXToY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveScaleXToY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>581</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveScaleXToY--> + <!--DFFOPT perspectiveScaleYToY--> + <UML:Class xmi.id="perspectiveScaleYToY" name="perspectiveScaleYToY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveScaleYToY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>582</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveScaleYToY--> + <!--DFFOPT perspectivePerspectiveX--> + <UML:Class xmi.id="perspectivePerspectiveX" name="perspectivePerspectiveX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectivePerspectiveX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>583</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectivePerspectiveX--> + <!--DFFOPT perspectivePerspectiveY--> + <UML:Class xmi.id="perspectivePerspectiveY" name="perspectivePerspectiveY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectivePerspectiveY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>584</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectivePerspectiveY--> + <!--DFFOPT perspectiveWeight--> + <UML:Class xmi.id="perspectiveWeight" name="perspectiveWeight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveWeight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>585</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Scaling + factor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveWeight--> + <!--DFFOPT perspectiveOriginX--> + <UML:Class xmi.id="perspectiveOriginX" name="perspectiveOriginX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveOriginX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>586</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveOriginX--> + <!--DFFOPT perspectiveOriginY--> + <UML:Class xmi.id="perspectiveOriginY" name="perspectiveOriginY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpperspectiveOriginY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>587</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1<<15</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT perspectiveOriginY--> + <!--DFFOPT fPerspective--> + <UML:Class xmi.id="fPerspective" name="fPerspective"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfPerspective</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>639</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>On/off</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fPerspective--> + <!--DFFOPT c3DSpecularAmt--> + <UML:Class xmi.id="c3DSpecularAmt" name="c3DSpecularAmt"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DSpecularAmt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>640</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed-point + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DSpecularAmt--> + <!--DFFOPT c3DDiffuseAmt--> + <UML:Class xmi.id="c3DDiffuseAmt" name="c3DDiffuseAmt"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DDiffuseAmt</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>641</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>65536</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed-point + 16.16</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DDiffuseAmt--> + <!--DFFOPT c3DShininess--> + <UML:Class xmi.id="c3DShininess" name="c3DShininess"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DShininess</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>642</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>5</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Default gives + OK results</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DShininess--> + <!--DFFOPT c3DEdgeThickness--> + <UML:Class xmi.id="c3DEdgeThickness" name="c3DEdgeThickness"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DEdgeThickness</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>643</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>12700</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Specular edge + thickness</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DEdgeThickness--> + <!--DFFOPT c3DExtrudeForward--> + <UML:Class xmi.id="c3DExtrudeForward" name="c3DExtrudeForward"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DExtrudeForward</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>644</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Distance of + extrusion in EMUs</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DExtrudeForward--> + <!--DFFOPT c3DExtrudeBackward--> + <UML:Class xmi.id="c3DExtrudeBackward" name="c3DExtrudeBackward"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DExtrudeBackward</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>645</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>457200</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DExtrudeBackward--> + <!--DFFOPT c3DExtrudePlane--> + <UML:Class xmi.id="c3DExtrudePlane" name="c3DExtrudePlane"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DExtrudePlane</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>646</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Extrusion + direction</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DExtrudePlane--> + <!--DFFOPT c3DExtrusionColor--> + <UML:Class xmi.id="c3DExtrusionColor" name="c3DExtrusionColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DExtrusionColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>647</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FillThenLine</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Basic color + of extruded part of shape; the lighting model used will determine + the exact shades used when rendering.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DExtrusionColor--> + <!--DFFOPT c3DCrMod--> + <UML:Class xmi.id="c3DCrMod" name="c3DCrMod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DCrMod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>648</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>undefined</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Modification + for BW views</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DCrMod--> + <!--DFFOPT f3D--> + <UML:Class xmi.id="f3D" name="f3D"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpf3D</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>700</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Does this + shape have a 3D effect?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT f3D--> + <!--DFFOPT fc3DMetallic--> + <UML:Class xmi.id="fc3DMetallic" name="fc3DMetallic"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DMetallic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>701</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Use metallic + specularity?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DMetallic--> + <!--DFFOPT fc3DUseExtrusionColor--> + <UML:Class xmi.id="fc3DUseExtrusionColor" name="fc3DUseExtrusionColor"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DUseExtrusionColor</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>702</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DUseExtrusionColor--> + <!--DFFOPT fc3DLightFace--> + <UML:Class xmi.id="fc3DLightFace" name="fc3DLightFace"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DLightFace</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>703</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DLightFace--> + <!--DFFOPT c3DYRotationAngle--> + <UML:Class xmi.id="c3DYRotationAngle" name="c3DYRotationAngle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DYRotationAngle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>704</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>degrees (16.16) about y + axis</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DYRotationAngle--> + <!--DFFOPT c3DXRotationAngle--> + <UML:Class xmi.id="c3DXRotationAngle" name="c3DXRotationAngle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DXRotationAngle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>705</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>degrees (16.16) about x + axis</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DXRotationAngle--> + <!--DFFOPT c3DRotationAxisX--> + <UML:Class xmi.id="c3DRotationAxisX" name="c3DRotationAxisX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationAxisX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>706</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>100</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>These specify the + rotation axis; only their relative magnitudes matter.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationAxisX--> + <!--DFFOPT c3DRotationAxisY--> + <UML:Class xmi.id="c3DRotationAxisY" name="c3DRotationAxisY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationAxisY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>707</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationAxisY--> + <!--DFFOPT c3DRotationAxisZ--> + <UML:Class xmi.id="c3DRotationAxisZ" name="c3DRotationAxisZ"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationAxisZ</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>708</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationAxisZ--> + <!--DFFOPT c3DRotationAngle--> + <UML:Class xmi.id="c3DRotationAngle" name="c3DRotationAngle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationAngle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>709</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>degrees (16.16) about + axis</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationAngle--> + <!--DFFOPT c3DRotationCenterX--> + <UML:Class xmi.id="c3DRotationCenterX" name="c3DRotationCenterX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationCenterX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>710</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rotation center x (16.16 + or g-units)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationCenterX--> + <!--DFFOPT c3DRotationCenterY--> + <UML:Class xmi.id="c3DRotationCenterY" name="c3DRotationCenterY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationCenterY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>711</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rotation center y (16.16 + or g-units)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationCenterY--> + <!--DFFOPT c3DRotationCenterZ--> + <UML:Class xmi.id="c3DRotationCenterZ" name="c3DRotationCenterZ"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRotationCenterZ</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>712</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>rotation center z + (absolute (emus))</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRotationCenterZ--> + <!--DFFOPT c3DRenderMode--> + <UML:Class xmi.id="c3DRenderMode" name="c3DRenderMode"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DRenderMode</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>713</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FullRender</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Full,wireframe, or + bcube</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DRenderMode--> + <!--DFFOPT c3DTolerance--> + <UML:Class xmi.id="c3DTolerance" name="c3DTolerance"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DTolerance</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>714</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>30000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>pixels + (16.16)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DTolerance--> + <!--DFFOPT c3DXViewpoint--> + <UML:Class xmi.id="c3DXViewpoint" name="c3DXViewpoint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DXViewpoint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>715</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1250000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>X view point + (emus)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DXViewpoint--> + <!--DFFOPT c3DYViewpoint--> + <UML:Class xmi.id="c3DYViewpoint" name="c3DYViewpoint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DYViewpoint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>716</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>-1250000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Y view point + (emus)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DYViewpoint--> + <!--DFFOPT c3DZViewpoint--> + <UML:Class xmi.id="c3DZViewpoint" name="c3DZViewpoint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DZViewpoint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>717</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9000000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Z view distance + (emus)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DZViewpoint--> + <!--DFFOPT c3DOriginX--> + <UML:Class xmi.id="c3DOriginX" name="c3DOriginX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DOriginX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>718</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>32768</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DOriginX--> + <!--DFFOPT c3DOriginY--> + <UML:Class xmi.id="c3DOriginY" name="c3DOriginY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DOriginY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>719</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>-32768</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DOriginY--> + <!--DFFOPT c3DSkewAngle--> + <UML:Class xmi.id="c3DSkewAngle" name="c3DSkewAngle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DSkewAngle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>720</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>-8847360</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>degree (16.16) skew + angle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DSkewAngle--> + <!--DFFOPT c3DSkewAmount--> + <UML:Class xmi.id="c3DSkewAmount" name="c3DSkewAmount"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DSkewAmount</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>721</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>50</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Percentage skew + amount</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DSkewAmount--> + <!--DFFOPT c3DAmbientIntensity--> + <UML:Class xmi.id="c3DAmbientIntensity" name="c3DAmbientIntensity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DAmbientIntensity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>722</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>20000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed point + intensity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DAmbientIntensity--> + <!--DFFOPT c3DKeyX--> + <UML:Class xmi.id="c3DKeyX" name="c3DKeyX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DKeyX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>723</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>50000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Key light source + direc-</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DKeyX--> + <!--DFFOPT c3DKeyY--> + <UML:Class xmi.id="c3DKeyY" name="c3DKeyY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DKeyY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>724</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>tion; only their + relative</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DKeyY--> + <!--DFFOPT c3DKeyZ--> + <UML:Class xmi.id="c3DKeyZ" name="c3DKeyZ"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DKeyZ</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>725</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>magnitudes + matter</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DKeyZ--> + <!--DFFOPT c3DKeyIntensity--> + <UML:Class xmi.id="c3DKeyIntensity" name="c3DKeyIntensity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DKeyIntensity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>726</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>38000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed point + intensity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DKeyIntensity--> + <!--DFFOPT c3DFillX--> + <UML:Class xmi.id="c3DFillX" name="c3DFillX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DFillX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>727</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>-50000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fill light source + direc-</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DFillX--> + <!--DFFOPT c3DFillY--> + <UML:Class xmi.id="c3DFillY" name="c3DFillY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DFillY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>728</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>tion; only their + relative</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DFillY--> + <!--DFFOPT c3DFillZ--> + <UML:Class xmi.id="c3DFillZ" name="c3DFillZ"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DFillZ</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>729</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>10000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>magnitudes + matter</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DFillZ--> + <!--DFFOPT c3DFillIntensity--> + <UML:Class xmi.id="c3DFillIntensity" name="c3DFillIntensity"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpc3DFillIntensity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>730</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>38000</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Fixed point + intensity</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT c3DFillIntensity--> + <!--DFFOPT fc3DConstrainRotation--> + <UML:Class xmi.id="fc3DConstrainRotation" name="fc3DConstrainRotation"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DConstrainRotation</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>763</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DConstrainRotation--> + <!--DFFOPT fc3DRotationCenterAuto--> + <UML:Class xmi.id="fc3DRotationCenterAuto" name="fc3DRotationCenterAuto"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DRotationCenterAuto</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>764</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DRotationCenterAuto--> + <!--DFFOPT fc3DParallel--> + <UML:Class xmi.id="fc3DParallel" name="fc3DParallel"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DParallel</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>765</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Parallel + projection?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DParallel--> + <!--DFFOPT fc3DKeyHarsh--> + <UML:Class xmi.id="fc3DKeyHarsh" name="fc3DKeyHarsh"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DKeyHarsh</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>766</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Is key lighting + harsh?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DKeyHarsh--> + <!--DFFOPT fc3DFillHarsh--> + <UML:Class xmi.id="fc3DFillHarsh" name="fc3DFillHarsh"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfc3DFillHarsh</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>767</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Is fill lighting + harsh?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fc3DFillHarsh--> + <!--DFFOPT hspMaster--> + <UML:Class xmi.id="hspMaster" name="hspMaster"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shphspMaster</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>769</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>master + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT hspMaster--> + <!--DFFOPT cxstyle--> + <UML:Class xmi.id="cxstyle" name="cxstyle"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpcxstyle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>771</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>None</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Type of + connector</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT cxstyle--> + <!--DFFOPT bWMode--> + <UML:Class xmi.id="bWMode" name="bWMode"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpbWMode</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>772</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Automatic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Settings for + modifications to be made when in different forms of black-and-white + mode.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT bWMode--> + <!--DFFOPT bWModePureBW--> + <UML:Class xmi.id="bWModePureBW" name="bWModePureBW"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpbWModePureBW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>773</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Automatic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT bWModePureBW--> + <!--DFFOPT bWModeBW--> + <UML:Class xmi.id="bWModeBW" name="bWModeBW"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpbWModeBW</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>774</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Automatic</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT bWModeBW--> + <!--DFFOPT fOleIcon--> + <UML:Class xmi.id="fOleIcon" name="fOleIcon"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfOleIcon</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>826</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>For OLE + objects, whether the object is in icon form</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fOleIcon--> + <!--DFFOPT fPreferRelativeResize--> + <UML:Class xmi.id="fPreferRelativeResize" name="fPreferRelativeResize"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfPreferRelativeResize</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>827</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>For UI only. + Prefer relative resizing.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fPreferRelativeResize--> + <!--DFFOPT fLockShapeType--> + <UML:Class xmi.id="fLockShapeType" name="fLockShapeType"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfLockShapeType</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>828</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Lock the + shape type (don't allow Change Shape)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fLockShapeType--> + <!--DFFOPT fDeleteAttachedObject--> + <UML:Class xmi.id="fDeleteAttachedObject" name="fDeleteAttachedObject"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfDeleteAttachedObject</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>830</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fDeleteAttachedObject--> + <!--DFFOPT fBackground--> + <UML:Class xmi.id="fBackground" name="fBackground"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfBackground</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>831</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>If TRUE, this + is the background shape.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fBackground--> + <!--DFFOPT spcot--> + <UML:Class xmi.id="spcot" name="spcot"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpspcot</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>832</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TwoSegment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Callout type</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT spcot--> + <!--DFFOPT dxyCalloutGap--> + <UML:Class xmi.id="dxyCalloutGap" name="dxyCalloutGap"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxyCalloutGap</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>833</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/12 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Distance from box to + first point.(EMUs)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxyCalloutGap--> + <!--DFFOPT spcoa--> + <UML:Class xmi.id="spcoa" name="spcoa"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpspcoa</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>834</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Any</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Callout angle</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT spcoa--> + <!--DFFOPT spcod--> + <UML:Class xmi.id="spcod" name="spcod"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpspcod</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>835</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Specified</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Callout drop + type</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT spcod--> + <!--DFFOPT dxyCalloutDropSpecified--> + <UML:Class xmi.id="dxyCalloutDropSpecified" name="dxyCalloutDropSpecified"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxyCalloutDropSpecified</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>836</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>9 points</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>if msospcodSpecified, the + actual drop distance</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxyCalloutDropSpecified--> + <!--DFFOPT dxyCalloutLengthSpecified--> + <UML:Class xmi.id="dxyCalloutLengthSpecified" name="dxyCalloutLengthSpecified"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxyCalloutLengthSpecified</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>837</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>if + fCalloutLengthSpecified, the actual distance</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxyCalloutLengthSpecified--> + <!--DFFOPT fCallout--> + <UML:Class xmi.id="fCallout" name="fCallout"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCallout</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>889</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Is the shape a + callout?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCallout--> + <!--DFFOPT fCalloutAccentBar--> + <UML:Class xmi.id="fCalloutAccentBar" name="fCalloutAccentBar"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCalloutAccentBar</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>890</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>does callout have accent + bar</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCalloutAccentBar--> + <!--DFFOPT fCalloutTextBorder--> + <UML:Class xmi.id="fCalloutTextBorder" name="fCalloutTextBorder"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCalloutTextBorder</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>891</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>does callout have a text + border</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCalloutTextBorder--> + <!--DFFOPT fCalloutMinusX--> + <UML:Class xmi.id="fCalloutMinusX" name="fCalloutMinusX"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCalloutMinusX</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>892</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCalloutMinusX--> + <!--DFFOPT fCalloutMinusY--> + <UML:Class xmi.id="fCalloutMinusY" name="fCalloutMinusY"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCalloutMinusY</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>893</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCalloutMinusY--> + <!--DFFOPT fCalloutDropAuto--> + <UML:Class xmi.id="fCalloutDropAuto" name="fCalloutDropAuto"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCalloutDropAuto</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>894</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>If true, then we + occasionally invert the drop distance</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCalloutDropAuto--> + <!--DFFOPT fCalloutLengthSpecified--> + <UML:Class xmi.id="fCalloutLengthSpecified" name="fCalloutLengthSpecified"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfCalloutLengthSpecified</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>895</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>if true, we look at + dxyCalloutLengthSpecified</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fCalloutLengthSpecified--> + <!--DFFOPT wzName--> + <UML:Class xmi.id="wzName" name="wzName"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpwzName</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>896</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Shape Name (present only + if explicitly set)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT wzName--> + <!--DFFOPT wzDescription--> + <UML:Class xmi.id="wzDescription" name="wzDescription"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpwzDescription</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>897</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>String</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>alternate + text</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT wzDescription--> + <!--DFFOPT pihlShape--> + <UML:Class xmi.id="pihlShape" name="pihlShape"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppihlShape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>898</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The hyperlink in the + shape.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pihlShape--> + <!--DFFOPT pWrapPolygonVertices--> + <UML:Class xmi.id="pWrapPolygonVertices" name="pWrapPolygonVertices"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shppWrapPolygonVertices</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>899</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>unknown</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>NULL</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>The polygon that text + will be wrapped around (Word)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT pWrapPolygonVertices--> + <!--DFFOPT dxWrapDistLeft--> + <UML:Class xmi.id="dxWrapDistLeft" name="dxWrapDistLeft"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxWrapDistLeft</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>900</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/8 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Left wrapping distance + from text (Word)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxWrapDistLeft--> + <!--DFFOPT dyWrapDistTop--> + <UML:Class xmi.id="dyWrapDistTop" name="dyWrapDistTop"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdyWrapDistTop</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>901</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Top wrapping distance + from text (Word)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dyWrapDistTop--> + <!--DFFOPT dxWrapDistRight--> + <UML:Class xmi.id="dxWrapDistRight" name="dxWrapDistRight"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdxWrapDistRight</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>902</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1/8 inch</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Right wrapping distance + from text (Word)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dxWrapDistRight--> + <!--DFFOPT dyWrapDistBottom--> + <UML:Class xmi.id="dyWrapDistBottom" name="dyWrapDistBottom"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpdyWrapDistBottom</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>903</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Bottom wrapping distance + from text (Word)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT dyWrapDistBottom--> + <!--DFFOPT lidRegroup--> + <UML:Class xmi.id="lidRegroup" name="lidRegroup"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shplidRegroup</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>904</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U32</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>0</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Regroup ID</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT lidRegroup--> + <!--DFFOPT fEditedWrap--> + <UML:Class xmi.id="fEditedWrap" name="fEditedWrap"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfEditedWrap</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>953</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Has the wrap polygon been + edited?</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fEditedWrap--> + <!--DFFOPT fBehindDocument--> + <UML:Class xmi.id="fBehindDocument" name="fBehindDocument"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfBehindDocument</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>954</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Word-only (shape is + behind text)</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fBehindDocument--> + <!--DFFOPT fOnDblClickNotify--> + <UML:Class xmi.id="fOnDblClickNotify" name="fOnDblClickNotify"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfOnDblClickNotify</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>955</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Notify client on a double + click</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fOnDblClickNotify--> + <!--DFFOPT fIsButton--> + <UML:Class xmi.id="fIsButton" name="fIsButton"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfIsButton</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>956</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>A button shape (i.e., + clicking performs an action). Set for shapes with attached + hyperlinks or macros.</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fIsButton--> + <!--DFFOPT fOneD--> + <UML:Class xmi.id="fOneD" name="fOneD"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfOneD</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>957</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1D adjustment</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fOneD--> + <!--DFFOPT fHidden--> + <UML:Class xmi.id="fHidden" name="fHidden"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfHidden</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>958</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>FALSE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Do not + display</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fHidden--> + <!--DFFOPT fPrint--> + <UML:Class xmi.id="fPrint" name="fPrint"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="dffopt"/> + </UML:ModelElement.stereotype> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>dff:shpfPrint</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="optname"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>959</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="fopid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>U8</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="type"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>1</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="isbool"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>TRUE</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="default"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue>Print this + shape</UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </UML:Class> + <!--DFFOPT fPrint--> + <!--DFFOPT--> + </UML:Namespace.ownedElement> + </UML:Model> + </XMI.content> +</XMI> diff --git a/writerfilter/source/doctok/resources.xsl b/writerfilter/source/doctok/resources.xsl new file mode 100644 index 000000000000..5ff0efe0edd1 --- /dev/null +++ b/writerfilter/source/doctok/resources.xsl @@ -0,0 +1,917 @@ +<!-- +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> + <xsl:output method="text" /> + + <xsl:template match="/"> + <out xml:space="preserve"> + <xsl:text> +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * http://www.openoffice.org/license.html + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +/* + + THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT! + +*/ +#ifndef INCLUDED_RESOURCES_HXX +#define INCLUDED_RESOURCES_HXX + +#include <vector> +#include <boost/shared_ptr.hpp> + +#ifndef INCLUDED_OUTPUT_WITH_DEPTH_HXX +#include <resourcemodel/OutputWithDepth.hxx> +#endif + +#ifndef INCLUDED_RESOURCESIDS_HXX +#include <doctok/resourceids.hxx> +#endif + +#ifndef INCLUDED_WW8_STRUCT_BASE_HXX +#include <WW8StructBase.hxx> +#endif + +#ifndef INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX +#include <WW8ResourceModelImpl.hxx> +#endif + +#ifndef INCLUDED_WW8_PROPERTY_SET_IMPL_HXX +#include <WW8PropertySetImpl.hxx> +#endif + +#ifndef INCLUDED_DFF_HXX +#include <Dff.hxx> +#endif + +namespace writerfilter { +namespace doctok { + +class WW8DocumentImpl; +typedef const WW8DocumentImpl * WW8DocumentImplPointer; + +using namespace ::std;
</xsl:text> + <xsl:apply-templates select="//UML:Class" mode="class"/> + <xsl:text> +rtl::OUString getDffOptName(sal_uInt32 nPid); +bool isBooleanDffOpt(sal_uInt32 nId); +}} +#endif // INCLUDED_RESOURCES_HXX
</xsl:text></out> +</xsl:template> + + <xsl:template match="UML:Class" mode="class"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "ww8resource"]'> + <xsl:apply-templates select="." mode="ww8resource"/> + </xsl:when> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "dffrecord"]'> + <xsl:apply-templates select="." mode="dffrecord"/> + </xsl:when> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "dffopt"]'> + <xsl:apply-templates select="." mode="dffopt"/> + </xsl:when> + </xsl:choose> + </xsl:template> + + <xsl:template match="UML:Class" mode="ww8resource"> + <xsl:variable name="parentresource"> + <xsl:call-template name='parenttype'> + <xsl:with-param name='type'><xsl:value-of select='@xmi.id'/></xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:variable name='size_'><xsl:value-of select='./*/UML:TaggedValue[./*/UML:TagDefinition/@xmi.idref="size"]/UML:TaggedValue.dataValue'/></xsl:variable> + <xsl:variable name='size'> + <xsl:choose> + <xsl:when test='$size_ != ""'><xsl:value-of select='$size_'/></xsl:when> + <xsl:otherwise>0</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="classname">WW8<xsl:value-of select="@name"/></xsl:variable> + <xsl:variable name="superclass"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "ww8sprm"]'>WW8PropertyImpl</xsl:when> + <xsl:otherwise>WW8StructBase</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="surroundclass"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "ww8sprm"]'>WW8PropertyImpl</xsl:when> + <xsl:otherwise>WW8StructBase</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:text> +/** + Automatically generated class: </xsl:text><xsl:value-of select="@name"/><xsl:text> + </xsl:text> + <xsl:for-each select='./UML:ModelElement.stereotype/UML:Stereotype'> + <xsl:text> + Stereotype </xsl:text> + <xsl:value-of select='@xmi.idref'/> + <xsl:text>
</xsl:text> + </xsl:for-each> + <xsl:text> + Parent Resource: </xsl:text> + <xsl:value-of select="$parentresource"/> + <xsl:text> + Size: </xsl:text><xsl:value-of select='$size'/> + <xsl:text> +*/ +class </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>: public </xsl:text> + <xsl:value-of select='$superclass'/> + <xsl:if test='$parentresource != ""'> + <xsl:text>, public writerfilter::Reference< </xsl:text> + <xsl:value-of select='$parentresource'/> + <xsl:text>></xsl:text> + </xsl:if> + <xsl:text> +{</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withindex"]'> + <xsl:text> sal_uInt32 mnIndex;</xsl:text> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withmembers"]'> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:apply-templates select='.' mode='declmembers'/> + </xsl:for-each> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="needsdocument"]'> + <xsl:text> WW8DocumentImplPointer mpDoc;
</xsl:text> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="plcf"]'> + <xsl:text> + sal_uInt32 mnPlcfPayloadOffset; + vector<sal_uInt32> entryOffsets; + vector<sal_uInt32> payloadOffsets; + vector<sal_uInt32> payloadIndices; + </xsl:text> + </xsl:if> + <xsl:text> + public: + typedef boost::shared_ptr<</xsl:text> + <xsl:value-of select='$classname'/> + <xsl:text>> Pointer_t; + + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>( + WW8Stream & rStream, + sal_uInt32 nOffset = 0, + sal_uInt32 nCount = </xsl:text> + <xsl:value-of select='$size'/> + <xsl:text>) + : </xsl:text><xsl:value-of select='$superclass'/> + <xsl:text>(rStream, nOffset, nCount)</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withindex"]'> + <xsl:text>, mnIndex(0)</xsl:text> + </xsl:if> + <xsl:text> + { + init(); + } + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>( + WW8StructBase * pParent, + sal_uInt32 nOffset = 0, + sal_uInt32 nCount = </xsl:text> + <xsl:value-of select='$size'/> + <xsl:text>) + : </xsl:text> + <xsl:value-of select='$superclass'/> + <xsl:text>(pParent, nOffset, nCount)</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withindex"]'> + <xsl:text>, mnIndex(0)</xsl:text> + </xsl:if> + <xsl:text> + { + init(); + }
 </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>( const </xsl:text> + <xsl:value-of select='$surroundclass'/> + <xsl:text>& rSurround, + sal_uInt32 nOffset = 0, sal_uInt32 nCount = </xsl:text> + <xsl:value-of select='$size'/>) + <xsl:text> + : </xsl:text> + <xsl:value-of select='$superclass'/> + <xsl:text>(rSurround, nOffset, nCount)</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withindex"]'> + <xsl:text>, mnIndex(0)</xsl:text> + </xsl:if> + <xsl:text> + { + init(); + }
 + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>( + const Sequence & + rSequence, sal_uInt32 nOffset = 0, + sal_uInt32 nCount = </xsl:text> + <xsl:value-of select='$size'/> + <xsl:text>) + : </xsl:text> + <xsl:value-of select='$superclass'/> + <xsl:text>(rSequence, nOffset, nCount)</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withindex"]'> + <xsl:text>, mnIndex(0)</xsl:text> + </xsl:if> + <xsl:text> + { + init(); + } + + virtual ~</xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>();
</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="initimpl"]'> + <xsl:text> void initImpl();
</xsl:text> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="plcf"]'> + <xsl:text> void initPayload();</xsl:text> + </xsl:if> + <xsl:text> + void init(); + + /** + Return type of resource. + */ + virtual string getType() const + { + return "</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>"; + } + + /** + Return static size. + */ + static sal_uInt32 getSize() { return </xsl:text> + <xsl:value-of select='$size'/> + <xsl:text>; }</xsl:text> + <xsl:if test="not(.//UML:Stereotype[@xmi.ref='ww8nocalcsize'])"> + <xsl:text> + /** + Calculate actual size. + */ + sal_uInt32 calcSize(); + </xsl:text> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="plcf"]'> + <xsl:text> + /** + Return offset for entry of PLCF. + + @param nIndex index of entry + */ + sal_uInt32 getEntryOffset(sal_uInt32 nIndex) + { + return entryOffsets[nIndex]; + }</xsl:text> + <xsl:if test="not(.//UML:Stereotype[@xmi.idref='ww8nopayloadoffset'])"> + <xsl:text> + /** + Calculate offset for payload. + */ + sal_uInt32 calcPayloadOffset();</xsl:text> + </xsl:if> + <xsl:text> + /** + Set offset for payloads. + + @param nOffset the offset to set + */ + void setPayloadOffset(sal_uInt32 nOffset) + { + mnPlcfPayloadOffset = nOffset; + } + + /** + Return offset for payload of PLCF. + + @param nIndex index of entry + */ + sal_uInt32 getPayloadOffset(sal_uInt32 nIndex) + { + return payloadOffsets[nIndex]; + } + + /** + Return size of payload. + */ + sal_uInt32 getPayloadSize(sal_uInt32 nIndex) const + { + return payloadOffsets[nIndex + 1] - payloadOffsets[nIndex]; + } + + + /** + Return payload index of an entry. + + */ + sal_uInt32 getPayloadIndex(sal_uInt32 nIndex) + { + return payloadIndices[nIndex]; + } + </xsl:text> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withindex"]'> + <xsl:text> + /** + Set index in parent. + + @param nIndex the index + */ + void setIndex(sal_uInt32 nIndex) { mnIndex = nIndex; } + </xsl:text> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="ww8sprm"]'> + <xsl:variable name='propsreftype'>writerfilter::Reference < Properties >::Pointer_t</xsl:variable> + <xsl:text> /** + Return reference to properties of Sprm. + */ + </xsl:text> + <xsl:value-of select='$propsreftype'/> + <xsl:text> getProps() + { + return </xsl:text> + <xsl:value-of select='$propsreftype'/> + <xsl:text> (new </xsl:text> + <xsl:value-of select='$classname'/> + <xsl:text>(*this)); + } + </xsl:text> + </xsl:if> + + <xsl:if test='.//UML:Stereotype[@xmi.idref ="ww8sprmbinary"]'> + <xsl:text> + virtual writerfilter::Reference < BinaryObj > ::Pointer_t getBinary(); + </xsl:text> + </xsl:if> + + <xsl:if test='.//UML:Stereotype[@xmi.idref ="needsdocument"]'> + <xsl:text> + void setDoc(WW8DocumentImplPointer pDoc) + { + mpDoc = pDoc; + } + </xsl:text> + </xsl:if> + <xsl:apply-templates select="." mode="declsProperties"/> + <xsl:if test='$parentresource="Table"'> + <xsl:apply-templates select="." mode="declsTable"/> + </xsl:if> + <xsl:choose> + <xsl:when test='$parentresource="Properties"'> + <xsl:apply-templates select="." mode="resolveProperties"/> + </xsl:when> + <xsl:when test='$parentresource="Table"'> + <xsl:apply-templates select="." mode="resolveTable"/> + </xsl:when> + </xsl:choose> + <xsl:text> + }; + </xsl:text> + </xsl:template> + +<xsl:template match='UML:Class' mode='declsProperties'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref ="withmembers"]'> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:apply-templates select='.' mode='accessmembers'/> + </xsl:for-each> + </xsl:when> + <xsl:otherwise> + <xsl:variable name="debug"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="debug"]'> + <xsl:text>true</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:text>false</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:apply-templates select='.' mode='access'> + <xsl:with-param name="debug"> + <xsl:value-of select="$debug"/> + </xsl:with-param> + </xsl:apply-templates> + </xsl:for-each> + </xsl:otherwise> + </xsl:choose> + <xsl:for-each select='.//UML:Operation[@name!="reserved"]'> + <xsl:apply-templates select='.' mode='declsOperations'/> + </xsl:for-each> +</xsl:template> + +<xsl:template match="UML:Class" mode="resolveProperties"> + <xsl:if test='.//UML:Stereotype[@xmi.idref = "resolvenoauto"]'> + void resolveNoAuto(Properties & rHandler); + </xsl:if> + + void dump(OutputWithDepth < string > & o) const; + + void resolve(Properties & rHandler); +</xsl:template> + +<xsl:template match="UML:Class" mode="declsTable"> + sal_uInt32 getEntryCount(); + writerfilter::Reference< Properties >::Pointer_t getEntry(sal_uInt32 nIndex); +</xsl:template> + +<xsl:template match="UML:Class" mode="resolveTable"> + void resolve(Table & rHandler); +</xsl:template> + +<xsl:template match="UML:Attribute" mode="access"> + <xsl:param name="debug"/> + <xsl:variable name="stereotype"><xsl:value-of select=".//UML:Stereotype[1]/@xmi.idref"/></xsl:variable> + <xsl:variable name="offset_"><xsl:value-of select='translate(.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="offset"]/UML:TaggedValue.dataValue, "ABCDEFX", "abcdefx")'/></xsl:variable> + <xsl:variable name="offset"> + <xsl:value-of select='$offset_'/> + </xsl:variable> + <xsl:variable name="shift"><xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="shift"]/UML:TaggedValue.dataValue'/></xsl:variable> + <xsl:variable name="mask_"><xsl:value-of select='translate(.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="mask"]/UML:TaggedValue.dataValue, "ABCDEFX", "abcdefx")'/></xsl:variable> + <xsl:variable name="mask"> + <xsl:if test='$mask_ != "" and not(starts-with($mask_, "0x"))'>0x</xsl:if> + <xsl:value-of select='$mask_'/> + </xsl:variable> + <xsl:variable name='type'> + <xsl:value-of select="UML:StructuralFeature.type/UML:DataType/@xmi.idref"/> + </xsl:variable> + <xsl:variable name="completetype"> + <xsl:text>WW8</xsl:text> + <xsl:value-of select="$type"/> + </xsl:variable> + <xsl:variable name="saltype"> + <xsl:apply-templates select="." mode="returntype"/> + </xsl:variable> + <xsl:variable name='typetype'> + <xsl:call-template name='typetype'> + <xsl:with-param name='type'><xsl:value-of select="$type"/></xsl:with-param> + </xsl:call-template> + </xsl:variable> + + /** + <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="comment"]/UML:TaggedValue.dataValue'/> + + <table> + <tr> + <th> + Name + </th> + <td> + <xsl:value-of select='@name'/>(<xsl:value-of select='$stereotype'/>) + </td> + </tr> + <tr> + <th> + Offset + </th> + <td> + <xsl:value-of select='$offset'/> + </td> + </tr> + <tr> + <th> + Mask + </th> + <td> + <xsl:value-of select='$mask'/> + </td> + </tr> + <tr> + <th> + Shift + </th> + <td> + <xsl:value-of select='$shift'/> + </td> + </tr> + </table> + */ + +<xsl:choose> + <xsl:when test='$stereotype = "attribute"'> + <xsl:if test='././/UML:Stereotype[@xmi.idref="virtual"]'> + <xsl:text>virtual </xsl:text> + </xsl:if> + <xsl:value-of select='$saltype'/> get_<xsl:value-of select='@name'/>() const + { + <xsl:if test='$debug="true"'> + <xsl:text> + clog << "<called></xsl:text> + <xsl:value-of select="@name"/> + <xsl:text></called>" + << endl;
 + </xsl:text> + </xsl:if> + <xsl:choose> + <xsl:when test='././/UML:Stereotype[@xmi.idref="attributeremainder"]'> + <xsl:text>return writerfilter::Reference < BinaryObj >::Pointer_t(new WW8BinaryObjReference(getRemainder(</xsl:text> + <xsl:value-of select="$offset"/> + <xsl:text>)));
</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:choose> + <xsl:when test='$typetype = "complex"'> + <xsl:text> return </xsl:text> + <xsl:value-of select="$saltype"/> + <xsl:text>(new </xsl:text> + <xsl:value-of select="$completetype"/> + <xsl:text>(*this, </xsl:text> + <xsl:value-of select="$offset"/> + <xsl:text>));
</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:text> return (get</xsl:text> + <xsl:value-of select="$type"/> + <xsl:text>(</xsl:text> + <xsl:value-of select="$offset"/> + <xsl:text>)</xsl:text> + <xsl:if test="string-length($mask)>0"> + <xsl:text>& </xsl:text> + <xsl:value-of select="$mask"/> + </xsl:if> + <xsl:text>)</xsl:text> + <xsl:if test="$shift>0"> + <xsl:text>>> </xsl:text> + <xsl:value-of select="$shift"/> + </xsl:if> + <xsl:text>;</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:otherwise> + </xsl:choose> + } + </xsl:when> + <xsl:when test='$stereotype = "array"'> + <xsl:text>sal_uInt32 get_</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>_count() const </xsl:text> + <xsl:choose> + <xsl:when test='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = "arraycount"]'> + <xsl:text>{ return </xsl:text> + <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = "arraycount"]/UML:TaggedValue.dataValue'/> + <xsl:text>; }
</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:text>;
</xsl:text> + </xsl:otherwise> + </xsl:choose> + <xsl:value-of select='$saltype'/> + <xsl:text> get_</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>(sal_uInt32 nIndex) const {</xsl:text> + <xsl:choose> + <xsl:when test="$typetype='complex'"> + <xsl:text> return </xsl:text> + <xsl:value-of select="$saltype"/> + <xsl:text>( new </xsl:text> + <xsl:value-of select="$completetype"/> + <xsl:text>(static_cast<const WW8StructBase >(*this), </xsl:text> + <xsl:value-of select="$offset"/> + <xsl:text> + nIndex * </xsl:text> + <xsl:value-of select="$completetype"/> + <xsl:text>::getSize()));</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:text> return get</xsl:text> + <xsl:value-of select='$type'/> + <xsl:text>(</xsl:text><xsl:value-of select='$offset'/> + <xsl:text> + nIndex * sizeof(</xsl:text> + <xsl:value-of select='$saltype'/> + <xsl:text>))</xsl:text> + </xsl:otherwise> + </xsl:choose> + <xsl:text>; }
</xsl:text> + </xsl:when> + <xsl:when test='$stereotype = "string"'> + rtl::OUString get_<xsl:value-of select='@name'/>() const { return getString(<xsl:value-of select='$offset'/>); } + </xsl:when> +</xsl:choose> +</xsl:template> + +<xsl:template match='UML:Attribute' mode='accessmembers'> + <xsl:text> </xsl:text> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select='.//UML:DataType/@xmi.idref'/> + </xsl:with-param> + </xsl:call-template> + <xsl:text> get_</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>() const { return m</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>; } + </xsl:text> +</xsl:template> + + +<xsl:template match="UML:Operation" mode="declsOperations"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "array"'> + <xsl:variable name="elementtype"> + <xsl:value-of select='.//UML:Parameter.type/UML:Class/@xmi.idref'/> + </xsl:variable> + <xsl:variable name="parentclass"> + <xsl:call-template name='parenttype'> + <xsl:with-param name='type'> + <xsl:value-of select='$elementtype'/> + </xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:variable name='saltype'> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select='$elementtype'/> + </xsl:with-param> + <xsl:with-param name='parenttype'> + <xsl:value-of select='$parentclass'/> + </xsl:with-param> + </xsl:call-template> + </xsl:variable> + /** + Array: <xsl:value-of select="@name"/> + ElementType: <xsl:value-of select="$elementtype"/>(<xsl:value-of select="$parentclass"/>) + */ + + sal_uInt32 get_<xsl:value-of select="@name"/>_count(); + + <xsl:text> </xsl:text><xsl:value-of select='$saltype'/> get_<xsl:value-of select="@name"/>(sal_uInt32 pos); + </xsl:when> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "attribute" or .//UML:Stereotype/@xmi.idref = "binary"'> + <xsl:variable name="returntype_"> + <xsl:value-of select='.//UML:Parameter.type/UML:Class/@xmi.idref'/> + </xsl:variable> + <xsl:variable name="returntype"> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select='$returntype_'/> + </xsl:with-param> + <xsl:with-param name='parenttype'> + <xsl:call-template name='parenttype'> + <xsl:with-param name='type'> + <xsl:value-of select='$returntype_'/> + </xsl:with-param> + </xsl:call-template> + </xsl:with-param> + </xsl:call-template> + </xsl:variable> + /** + Operation: <xsl:value-of select="@name"/> + */ + + <xsl:text> </xsl:text> + <xsl:value-of select='$returntype'/> + <xsl:text> get_</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>();
</xsl:text> + </xsl:when> + </xsl:choose> +</xsl:template> + +<xsl:template match="UML:Attribute" mode='declmembers'> + <xsl:text> </xsl:text> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select='.//UML:DataType/@xmi.idref'/> + </xsl:with-param> + </xsl:call-template> + <xsl:text> m</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>; + </xsl:text> +</xsl:template> + +<xsl:template name='idtoqname'> + <xsl:param name='id'/>NS_<xsl:value-of select='substring-before($id, ":")'/>::LN_<xsl:value-of select='substring-after($id, ":")'/> +</xsl:template> + +<xsl:template name='saltype'> + <xsl:param name='type'/> + <xsl:param name='parenttype'/> + <xsl:choose> + <xsl:when test="$type='U8'">sal_uInt8</xsl:when> + <xsl:when test="$type='S8'">sal_Int8</xsl:when> + <xsl:when test="$type='U16'">sal_uInt16</xsl:when> + <xsl:when test="$type='S16'">sal_Int16</xsl:when> + <xsl:when test="$type='U32'">sal_uInt32</xsl:when> + <xsl:when test="$type='S32'">sal_Int32</xsl:when> + <xsl:when test="$type='String'">rtl::OUString</xsl:when> + <xsl:when test="$type='Value'">WW8Value::Pointer_t</xsl:when> + <xsl:when test="$type='Binary'">WW8BinaryObjReference::Pointer_t</xsl:when> + <xsl:when test="$parenttype=''"> + <xsl:value-of select="$type"/> + </xsl:when> + <xsl:otherwise> + <xsl:text>writerfilter::Reference < </xsl:text> + <xsl:value-of select='$parenttype'/> + <xsl:text> >::Pointer_t</xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template name='typetype'> + <xsl:param name='type'/><xsl:choose> + <xsl:when test="$type='U8'">simple</xsl:when> + <xsl:when test="$type='S8'">simple</xsl:when> + <xsl:when test="$type='U16'">simple</xsl:when> + <xsl:when test="$type='S16'">simple</xsl:when> + <xsl:when test="$type='U32'">simple</xsl:when> + <xsl:when test="$type='S32'">simple</xsl:when> + <xsl:when test="$type='String'">string</xsl:when> + <xsl:when test="$type='Value'">value</xsl:when> + <xsl:otherwise>complex</xsl:otherwise> +</xsl:choose> +</xsl:template> + +<xsl:template match="UML:Attribute" mode="valuetype"> + <xsl:variable name='type'> + <xsl:value-of select='.//UML:DataType/@xmi.idref'/> + </xsl:variable> + <xsl:choose> + <xsl:when test='$type="U8"'>WW8IntValue</xsl:when> + <xsl:when test='$type="S8"'>WW8IntValue</xsl:when> + <xsl:when test='$type="U16"'>WW8IntValue</xsl:when> + <xsl:when test='$type="S16"'>WW8IntValue</xsl:when> + <xsl:when test='$type="U32"'>WW8IntValue</xsl:when> + <xsl:when test='$type="S32"'>WW8IntValue</xsl:when> + <xsl:otherwise>WW8PropertiesValue</xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template match="UML:Class" mode="dffrecord"> + <xsl:variable name="classname"> + <xsl:text>Dff</xsl:text><xsl:value-of select="@name"/> + </xsl:variable> + <xsl:text> +/** + Automaticallay generated class: + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>
 +*/
 +class </xsl:text> +<xsl:value-of select="$classname"/> +<xsl:text> : public DffRecord +{ +public: + typedef boost::shared_ptr < </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text> > Pointer_t;
 + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>(WW8StructBase * pParent, sal_uInt32 nOffset, sal_uInt32 nCount)
 + : DffRecord(pParent, nOffset, nCount) {}
 + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount)
 + : DffRecord(rStream, nOffset, nCount) {}
 + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>(DffRecord & rRecord)
 + : DffRecord(rRecord) {} + virtual ~</xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>(); + + virtual void resolveLocal(Properties & props);</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref = "resolvenoauto"]'> + void resolveNoAuto(Properties & rHandler); + </xsl:if> + <xsl:text> + virtual void dump(OutputWithDepth < string > & o) const; + + virtual DffRecord * clone() const { return new </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>(*this); }
 + virtual string getType() const + { + return "</xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>"; + } + + virtual string getName() const { return ""; } + </xsl:text> + <xsl:apply-templates select="." mode="declsProperties"/> + <xsl:text> +}; +</xsl:text> +</xsl:template> + + +<xsl:template match="UML:Class" mode="dffopt"> +<!-- + <xsl:variable name="classname"> + <xsl:text>DffOpt</xsl:text><xsl:value-of select="@name"/> + </xsl:variable> + <xsl:text> +/** + Automaticallay generated class: + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>
 +*/
 +class </xsl:text> +<xsl:value-of select="$classname"/> +<xsl:text> : public WW8FOPTE +{ + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>(WW8FOPTE & rOpt) : WW8FOPTE(rOpt) {} + + virtual string getName() const + { + return "</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>"; + }
</xsl:text> + + <xsl:text> +}; +</xsl:text> +--> +</xsl:template> + +<xsl:template name="parenttype"> + <xsl:param name='type'/> + <xsl:for-each select='/XMI/XMI.content/UML:Model/UML:Namespace.ownedElement/UML:Generalization[UML:Generalization.child/UML:Class/@xmi.idref=$type]'> + <xsl:value-of select='./UML:Generalization.parent/UML:Class/@xmi.idref'/> + </xsl:for-each> +</xsl:template> + +<xsl:template match="UML:Attribute" mode="returntype"> + <xsl:variable name='type'> + <xsl:value-of select="UML:StructuralFeature.type/UML:DataType/@xmi.idref"/> + </xsl:variable> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select="$type"/> + </xsl:with-param> + <xsl:with-param name='parenttype'> + <xsl:call-template name='parenttype'> + <xsl:with-param name='type'><xsl:value-of select='$type'/></xsl:with-param> + </xsl:call-template> + </xsl:with-param> + </xsl:call-template> +</xsl:template> + +</xsl:stylesheet> + diff --git a/writerfilter/source/doctok/resourcesimpl.xsl b/writerfilter/source/doctok/resourcesimpl.xsl new file mode 100644 index 000000000000..75684e76c95e --- /dev/null +++ b/writerfilter/source/doctok/resourcesimpl.xsl @@ -0,0 +1,855 @@ +<!-- +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output method="text" /> + + <xsl:include href="resourcetools.xsl"/> + +<xsl:template match="/"> + <xsl:call-template name="licenseheader"/> + <xsl:text> +#include <resources.hxx> + +#ifndef WW8_OUTPUT_WITH_DEPTH +#include <WW8OutputWithDepth.hxx> +#endif + +#ifndef INCLUDED_SPRMIDS_HXX +#include <sprmids.hxx> +#endif + +namespace writerfilter { +namespace doctok { + +extern WW8OutputWithDepth output; + +using namespace ::std; +</xsl:text> + <xsl:apply-templates select='/XMI/XMI.content/UML:Model' mode="sprmkind"/> + <xsl:apply-templates select='.//UML:Class' mode='class'/> + <xsl:apply-templates select='//UML:Model' mode='createsprmprops'/> + <xsl:apply-templates select='/XMI/XMI.content/UML:Model' + mode='createsprmbinary'/> + <xsl:apply-templates select='/XMI/XMI.content/UML:Model' + mode='createdffrecord'/> + <xsl:apply-templates select='/XMI/XMI.content/UML:Model' mode='ww8foptename'/> + <xsl:apply-templates select='/XMI/XMI.content/UML:Model' + mode='isbooleandffopt'/> + <xsl:text> +}} +</xsl:text> +</xsl:template> + + <xsl:template match="UML:Class" mode="class"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "ww8resource"]'> + <xsl:apply-templates select="." mode="ww8resource"> + <xsl:with-param name="classprefix">WW8</xsl:with-param> + <xsl:with-param name="needsinit">true</xsl:with-param> + </xsl:apply-templates> + </xsl:when> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "dffrecord"]'> + <xsl:apply-templates select="." mode="ww8resource"> + <xsl:with-param name="classprefix">Dff</xsl:with-param> + </xsl:apply-templates> + </xsl:when> + </xsl:choose> + </xsl:template> + + <xsl:template match="UML:Class" mode="ww8resource"> + <xsl:param name="classprefix"/> + <xsl:param name="needsinit"/> + <xsl:variable name="parentresource"> + <xsl:call-template name='parenttype'> + <xsl:with-param name='type'><xsl:value-of select='@xmi.id'/></xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:variable name='size_'><xsl:value-of select='./*/UML:TaggedValue[./*/UML:TagDefinition/@xmi.idref="size"]/UML:TaggedValue.dataValue'/></xsl:variable> + <xsl:variable name='size'> + <xsl:choose> + <xsl:when test='$size_ != ""'><xsl:value-of select='$size_'/></xsl:when> + <xsl:otherwise>0</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="classname"><xsl:value-of select="$classprefix"/><xsl:value-of select="@name"/></xsl:variable> + <xsl:variable name="superclass"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "ww8sprm"]'>WW8PropertyImpl</xsl:when> + <xsl:otherwise>WW8StructBase</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="surroundclass"> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "ww8sprm"]'>WW8PropertyImpl</xsl:when> + <xsl:otherwise>WW8StructBase</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:text> +/* + Automatically generated class: </xsl:text><xsl:value-of select="@name"/><xsl:text> + </xsl:text> + <xsl:for-each select='./UML:ModelElement.stereotype/UML:Stereotype'> + <xsl:text> + Stereotype </xsl:text> + <xsl:value-of select='@xmi.idref'/> + <xsl:text>
</xsl:text> + </xsl:for-each> + <xsl:text> + Parent Resource: </xsl:text> + <xsl:value-of select="$parentresource"/> + <xsl:text> + Size: </xsl:text><xsl:value-of select='$size'/> + <xsl:text> +*/ + </xsl:text> + + <xsl:value-of select="$classname"/> + <xsl:text>::~</xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>() + { + } + </xsl:text> + <xsl:if test="$needsinit='true'"> + <xsl:text> + void </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>::init() + { + </xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="withmembers"]'> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:apply-templates select='.' mode='initmembers'/> + </xsl:for-each> + </xsl:if> + <xsl:if test='.//UML:Stereotype[@xmi.idref ="initimpl"]'> + <xsl:text> initImpl();
</xsl:text> + </xsl:if> + <xsl:text> + }
</xsl:text> + </xsl:if> + + <xsl:choose> + <xsl:when test='$parentresource="Properties"'> + <xsl:apply-templates select="." mode="resolveProperties"> + <xsl:with-param name="classname" select="$classname"/> + </xsl:apply-templates> + </xsl:when> + <xsl:when test='$parentresource="Table"'> + <xsl:apply-templates select="." mode="resolveTable"> + <xsl:with-param name="classname" select="$classname"/> + </xsl:apply-templates> + </xsl:when> + </xsl:choose> + + </xsl:template> + + <xsl:template match="UML:Class" mode="resolveProperties"> + <xsl:param name="classname"/> + <xsl:variable name="rHandler"> + <xsl:choose> + <xsl:when test='.//UML:Attribute[@name!="reserved"]'> + <xsl:if test='.//UML:Stereotype[@xmi.idref != "noresolve"]'> + <xsl:text>rHandler</xsl:text> + </xsl:if> + </xsl:when> + <xsl:when test='.//UML:Operation[@name!="reserved"]'> + <xsl:if test='.//UML:Stereotype[@xmi.idref != "noresolve"]'> + <xsl:text>rHandler</xsl:text> + </xsl:if> + </xsl:when> + <xsl:when test='.//UML:Stereotype[@xmi.idref = "resolvenoauto"]'> + <xsl:text>rHandler</xsl:text> + </xsl:when> + </xsl:choose> + </xsl:variable> + <xsl:text> + void </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:choose> + <xsl:when test=".//UML:Stereotype[@xmi.idref='ww8resource']"> + <xsl:text>::resolve(Properties & </xsl:text> + <xsl:value-of select="$rHandler"/> + <xsl:text>)</xsl:text> + </xsl:when> + <xsl:when test=".//UML:Stereotype[@xmi.idref='dffrecord']"> + <xsl:text>::resolveLocal(Properties & </xsl:text> + <xsl:value-of select="$rHandler"/> + <xsl:text>)</xsl:text> + </xsl:when> + </xsl:choose> + <xsl:text> + {</xsl:text> + <xsl:if test='.//UML:Stereotype[@xmi.idref="debug"]'> + <xsl:text> + dump(output);</xsl:text> + </xsl:if> + <xsl:text> + try + {</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noresolve"]'> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select='.' mode='resolveAttribute'/> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:for-each select='.//UML:Operation[@name!="reserved"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noresolve"]'> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select='.' mode='resolveOperation'/> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + + <xsl:if test='.//UML:Stereotype[@xmi.idref = "resolvenoauto"]'> + resolveNoAuto(rHandler); + </xsl:if> + <xsl:text> + } catch (Exception & e) { + clog << e.getText() << endl; + } + } + + void + </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>::dump(OutputWithDepth < string > & o) const + { + o.addItem("<dump type='</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>'>"); + + WW8StructBase::dump(o);</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:apply-templates select='.' mode='dumpAttribute'/> + </xsl:for-each> + + <xsl:text> + o.addItem("</dump>"); + }
</xsl:text> + </xsl:template> + + <xsl:template match='UML:Attribute' mode='resolveAttribute'> + <xsl:variable name="attrid"> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:value-of select='UML:TaggedValue.dataValue'/> + </xsl:for-each> + </xsl:variable> + <xsl:variable name="qname"> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'> + <xsl:value-of select='$attrid'/> + </xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:choose> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "attribute"'> + <xsl:text> + { + WW8Value::Pointer_t pVal = createValue(get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>()); + rHandler.attribute(</xsl:text> + <xsl:value-of select="$qname"/> + <xsl:text>, *pVal); + }</xsl:text> + </xsl:when> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "array"'> + <xsl:variable name="elementtype"> + <xsl:value-of select='.//UML:DataType/@xmi.idref'/> + </xsl:variable> + <xsl:variable name="parentclass"> + <xsl:call-template name='parenttype'> + <xsl:with-param name='type'> + <xsl:value-of select='$elementtype'/> + </xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:text> + { + sal_uInt32 nCount = get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>_count(); + for (sal_uInt32 n = 0; n < nCount; ++n) + { + WW8Value::Pointer_t pVal = createValue(get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>(n)); + rHandler.attribute(</xsl:text> + <xsl:value-of select="$qname"/> + <xsl:text>, *pVal); + } + }</xsl:text> + </xsl:when> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "string"'> + <xsl:text> + { + WW8StringValue aVal(get_</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text>()); + rHandler.attribute(</xsl:text> + <xsl:value-of select="$qname"/> + <xsl:text>, aVal); + }</xsl:text> + </xsl:when> + </xsl:choose> + </xsl:template> + + <xsl:template match='UML:Attribute' mode='dumpAttribute'> + <xsl:variable name="type"> + <xsl:value-of select='.//UML:DataType/@xmi.idref'/> + </xsl:variable><xsl:variable name="saltype"> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select='$type'/> + </xsl:with-param> + <xsl:with-param name='parenttype'> + <xsl:apply-templates select="." mode="parentclass"/> + </xsl:with-param> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="name" select="@name"/> + <xsl:for-each select=".//UML:Stereotype"> + <xsl:choose> + <xsl:when test='@xmi.idref = "attributeremainder"'/> + <xsl:when test='@xmi.idref = "array"'> + <xsl:text> + { + sal_uInt32 nCount = get_</xsl:text> + <xsl:value-of select='$name'/> + <xsl:text>_count(); + + for (sal_uInt32 n = 0; n < nCount; ++n) + { + writerfilter::dump(o, "</xsl:text> + <xsl:value-of select='$name'/> + <xsl:text>", get_</xsl:text> + <xsl:value-of select="$name"/> + <xsl:text>(n)); + } + }</xsl:text> + </xsl:when> + <xsl:when test='@xmi.idref = "string"'> + <xsl:text> + { + WW8StringValue aVal(get_</xsl:text> + <xsl:value-of select='$name'/> + <xsl:text>()); + + o.addItem("</xsl:text> + <xsl:value-of select='$name'/> + <xsl:text>" << "=\"" + aVal.toString() + "\""); + }</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:text> + writerfilter::dump(o, "</xsl:text> + <xsl:value-of select='$name'/> + <xsl:text>", get_</xsl:text> + <xsl:value-of select="$name"/> + <xsl:text>());</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + </xsl:template> + + <xsl:template name="resolveOperationAttribute"> + <xsl:variable name="opid"> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:value-of select='./UML:TaggedValue.dataValue'/> + </xsl:for-each> + </xsl:variable> + <xsl:text> + { + WW8Value::Pointer_t pVal = createValue(get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>()); + rHandler.attribute(</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='$opid'/></xsl:with-param> + </xsl:call-template> + <xsl:text>, *pVal); + }
</xsl:text> + </xsl:template> + + <xsl:template name="resolveOperationArray"> + <xsl:variable name="elementtype"> + <xsl:value-of select='.//UML:Parameter.type/@xmi.idref'/> + </xsl:variable> + <xsl:variable name="opid"> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:value-of select='./UML:TaggedValue.dataValue'/> + </xsl:for-each> + </xsl:variable> + <xsl:variable name="parentclass"> + <xsl:for-each select='/XMI/XMI.content/UML:Model/UML:Namespace.ownedElement/UML:Generalization[UML:Generalization.child/UML:Class/@xmi.idref=$elementtype]'> + <xsl:value-of select='./UML:Generalization.parent/UML:Class/@xmi.idref'/> + </xsl:for-each> + </xsl:variable> + <xsl:text> + { + sal_uInt32 nCount = get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>_count(); + + for (sal_uInt32 n = 0; n < nCount; ++n) + { + WW8Value::Pointer_t pVal = createValue(get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>(n)); + rHandler.attribute(</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='$opid'/></xsl:with-param> + </xsl:call-template> + <xsl:text>, *pVal); + } + }
</xsl:text> + </xsl:template> + + <xsl:template name="resolveOperationBinary"> + <xsl:text> + { + WW8BinaryObjReference::Pointer_t pRef(get_</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>()); + WW8Sprm aSprm(pRef); + + rHandler.sprm(aSprm); + }
</xsl:text> + </xsl:template> + + <xsl:template match='UML:Operation' mode='resolveOperation'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "attribute"'> + <xsl:call-template name="resolveOperationAttribute"/> + </xsl:when> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "array"'> + <xsl:call-template name="resolveOperationArray"/> + </xsl:when> + <xsl:when test='.//UML:Stereotype/@xmi.idref = "binary"'> + <xsl:call-template name="resolveOperationBinary"/> + </xsl:when> + </xsl:choose> + </xsl:template> + + <xsl:template match="UML:Class" mode="resolveTable"> + <xsl:param name="classname"/> + <xsl:text>void </xsl:text> + <xsl:value-of select="$classname"/> + <xsl:text>::resolve(Table & rHandler) + { + sal_uInt32 nCount = getEntryCount(); + writerfilter::Reference< Properties >::Pointer_t pEntry; + for (sal_uInt32 n = 0; n < nCount; ++n) + { + pEntry = getEntry(n); + + if (pEntry.get() != 0x0) + { + try + { + rHandler.entry(n, pEntry); + } + catch (ExceptionOutOfBounds e) + { + } + } + } + } + </xsl:text> + </xsl:template> + +<xsl:template match='UML:Model' mode='createsprmprops'> +writerfilter::Reference < Properties > ::Pointer_t createSprmProps +(WW8PropertyImpl & rProp) +{ + writerfilter::Reference < Properties > ::Pointer_t pResult; + + switch (rProp.getId()) + { +<xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="ww8sprm" and .//UML:Stereotype/@xmi.idref="ww8resource"]'> + case <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="sprmcode"]//UML:TaggedValue.dataValue'/>: + pResult = writerfilter::Reference < Properties > ::Pointer_t(new WW8<xsl:value-of select='@name'/>(rProp, 0, rProp.getCount())); + + break; +</xsl:for-each> + default: + break; + } + + return pResult; +} +</xsl:template> + +<xsl:template match='UML:Model' mode='createsprmbinary'> +<xsl:text> +writerfilter::Reference < BinaryObj > ::Pointer_t createSprmBinary +(WW8PropertyImpl & rProp) +{ + writerfilter::Reference < BinaryObj > ::Pointer_t pResult; + + switch (rProp.getId()) + {
 + // warnings.... + case 0: + break; +</xsl:text> +<xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="ww8sprmbinary" and .//UML:Stereotype/@xmi.idref="ww8resource"]'> + case <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="sprmcode"]//UML:TaggedValue.dataValue'/>: + { + WW8<xsl:value-of select='@name'/>::Pointer_t p(new WW8<xsl:value-of select='@name'/>(rProp, 0, rProp.getCount())); + + pResult = p->getBinary(); + } + + break; +</xsl:for-each> +<xsl:text> + default: + break; + } + + return pResult; +} +</xsl:text> +</xsl:template> + +<!-- returns optname of UML:Class --> +<xsl:template name="optname"> + <xsl:for-each select="./UML:ModelElement.taggedValue/UML:TaggedValue"> + <xsl:if test=".//UML:TagDefinition/@xmi.idref='optname'"> + <xsl:value-of select="./UML:TaggedValue.dataValue"/> + </xsl:if> + </xsl:for-each> +</xsl:template> + +<xsl:template name="ww8foptenamecase"> + <xsl:text> + case </xsl:text> + <xsl:variable name="optname"> + <xsl:call-template name="optname"/> + </xsl:variable> + <xsl:call-template name="idtoqname"> + <xsl:with-param name="id" select="$optname"/> + </xsl:call-template> + <xsl:text>: + result = rtl::OUString::createFromAscii("</xsl:text> + <xsl:value-of select="$optname"/> + <xsl:text>"); + break;</xsl:text> +</xsl:template> + +<xsl:template name="getdffoptname"> + <xsl:text> +rtl::OUString getDffOptName(sal_uInt32 nPid) +{ + rtl::OUString result; + + switch (nPid) + {
</xsl:text> + <xsl:for-each select="./UML:Class[./UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='dffopt']"> + <xsl:call-template name="ww8foptenamecase"/> + </xsl:for-each> + <xsl:text> + default: + break; + } + + return result; +}</xsl:text> +</xsl:template> + +<xsl:template name="ww8foptegetvalue"> + <xsl:text> +WW8Value::Pointer_t WW8FOPTE::get_value() +{ + WW8Value::Pointer_t pResult; + + switch (get_pid()) + {</xsl:text> + <xsl:for-each select=".//UML:Class[./UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='dffopt']"> + <xsl:variable name="type"> + <xsl:for-each select="./UML:ModelElement.taggedValue/UML:TaggedValue[./UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='type']"> + <xsl:value-of select="UML:TaggedValue.dataValue"/> + </xsl:for-each> + </xsl:variable> + <xsl:if test="$type != 'unknown'"> + <xsl:variable name="typetype"> + <xsl:call-template name="typetype"> + <xsl:with-param name="type" select="$type"/> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="valuetype"> + <xsl:call-template name="valuetype"> + <xsl:with-param name="type" select="$type"/> + </xsl:call-template> + </xsl:variable> + <xsl:text> + case </xsl:text> + <xsl:for-each select="./UML:ModelElement.taggedValue/UML:TaggedValue[./UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='dffid']"> + <xsl:value-of select="UML:TaggedValue.dataValue"/> + </xsl:for-each> + <xsl:variable name="optname"> + <xsl:for-each select="./UML:ModelElement.taggedValue/UML:TaggedValue[./UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='optname']"> + <xsl:value-of select="UML:TaggedValue.dataValue"/> + </xsl:for-each> + </xsl:variable> + <xsl:call-template name="idtoqname"> + <xsl:with-param name="id" select="$optname"/> + </xsl:call-template> + <xsl:text>:</xsl:text> + <xsl:choose> + <xsl:when test="./UML:ModelElement.taggedValue/UML:TaggedValue[./UML:TaggedValue.type/UML:TagDefinition/@xmi.idref='isbool']"> + <xsl:text> + pResult = createValue(getU32(0x2) & 1);</xsl:text> + </xsl:when> + <xsl:when test="$typetype='complex'"> + <xsl:text> + pResult = createValue(new </xsl:text> + <xsl:value-of select="$valuetype"/> + <xsl:text>(getU32(0x2)));</xsl:text> + </xsl:when> + <xsl:when test="$typetype='string'"> + <xsl:text> + pResult = get_stringValue();
</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:text> + pResult = createValue(getU32(0x2));</xsl:text> + </xsl:otherwise> + </xsl:choose> + <xsl:text> + break;</xsl:text> + </xsl:if> + </xsl:for-each> + <xsl:text> + default: + pResult = createValue(getU32(0x2)); + + break; + } + + return pResult; +}</xsl:text> +</xsl:template> + +<xsl:template match='UML:Model/UML:Namespace.ownedElement' mode='ww8foptename'> + <xsl:text> +rtl::OUString WW8FOPTE::get_name() +{ + return getDffOptName(get_pid()); +}</xsl:text> +<xsl:call-template name="getdffoptname"/> +<xsl:text> + +WW8Value::Pointer_t WW8FOPTE::get_stringValue() +{ + WW8Value::Pointer_t pResult; + DffOPT * pOpt = dynamic_cast < DffOPT * >(mpParent); + sal_uInt32 nExtraOffset = pOpt->get_extraoffset(mnIndex); + sal_uInt32 nExtraLength = pOpt->get_extraoffset(mnIndex + 1) - nExtraOffset; + pResult = createValue(mpParent->getString(nExtraOffset, nExtraLength / 2)); + + return pResult; +} +</xsl:text> +<xsl:call-template name="ww8foptegetvalue"/> +</xsl:template> + +<xsl:template match="UML:Model" mode="createdffrecord"> +<xsl:text> +DffRecord * createDffRecord +(WW8StructBase * pParent, sal_uInt32 nOffset, sal_uInt32 * pCount) +{ + DffRecord * pResult = NULL; + DffRecord aTmpRec(pParent, nOffset, 8); + sal_uInt32 nSize = aTmpRec.calcSize(); + + if (pCount != NULL) + *pCount = nSize; + + switch (aTmpRec.getRecordType()) + {
</xsl:text> + <xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="dffrecord"]'> + <xsl:text> case </xsl:text> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref='dffid']//UML:TaggedValue.dataValue"/> + <xsl:text>: + pResult = new Dff</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>(pParent, nOffset, nSize); + + break;
</xsl:text> + </xsl:for-each> + <xsl:text> + default: + pResult = new DffRecord(pParent, nOffset, nSize); + + break; + } + + return pResult; +} + +DffRecord * createDffRecord +(WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 * pCount) +{ + DffRecord * pResult = NULL; + DffRecord aTmpRec(rStream, nOffset, 8); + sal_uInt32 nSize = aTmpRec.calcSize(); + + if (pCount != NULL) + *pCount = nSize; + + switch (aTmpRec.getRecordType()) + {
</xsl:text> + <xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="dffrecord"]'> + <xsl:text> case </xsl:text> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref='dffid']//UML:TaggedValue.dataValue"/> + <xsl:text>: + pResult = new Dff</xsl:text> + <xsl:value-of select="@name"/> + <xsl:text>(rStream, nOffset, nSize); + + break;
</xsl:text> + </xsl:for-each> + <xsl:text> + default: + pResult = new DffRecord(rStream, nOffset, nSize); + + break; + } + + return pResult; +} + </xsl:text> +</xsl:template> + +<xsl:template match="UML:Attribute" mode="initmembers"> + <xsl:variable name="stereotype"><xsl:value-of select=".//UML:Stereotype/@xmi.idref"/></xsl:variable> + <xsl:variable name="offset_"><xsl:value-of select='translate(.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="offset"]/UML:TaggedValue.dataValue, "ABCDEFX", "abcdefx")'/></xsl:variable> + <xsl:variable name="offset"> + <xsl:if test='$offset_ != "" and not(starts-with($offset_, "0x"))'>0x</xsl:if> + <xsl:value-of select='$offset_'/> + </xsl:variable> + <xsl:variable name="shift"><xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="shift"]/UML:TaggedValue.dataValue'/></xsl:variable> + <xsl:variable name="mask_"><xsl:value-of select='translate(.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="mask"]/UML:TaggedValue.dataValue, "ABCDEFX", "abcdefx")'/></xsl:variable> + <xsl:variable name="mask"> + <xsl:if test='$mask_ != "" and not(starts-with($mask_, "0x"))'>0x</xsl:if> + <xsl:value-of select='$mask_'/> + </xsl:variable> + <xsl:variable name="type"><xsl:value-of select='.//UML:DataType/@xmi.idref'/></xsl:variable><xsl:variable name="saltype"> + <xsl:call-template name='saltype'> + <xsl:with-param name='type'> + <xsl:value-of select='$type'/> + </xsl:with-param> + </xsl:call-template> +</xsl:variable> + +/* +<xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="comment"]/UML:TaggedValue.dataValue'/> + +Name: <xsl:value-of select='@name'/>(<xsl:value-of select='$stereotype'/>) +Offset: <xsl:value-of select='$offset'/> +Mask: <xsl:value-of select='$mask'/> +Shift: <xsl:value-of select='$shift'/> +*/ + +<xsl:choose> + <xsl:when test='$stereotype = "attribute"'> + m<xsl:value-of select='@name'/> = (get<xsl:value-of select="$type"/>(<xsl:value-of select="$offset"/>)<xsl:if test="string-length($mask)>0"> & <xsl:value-of select="$mask"/></xsl:if>)<xsl:if test="$shift>0"> >> <xsl:value-of select="$shift"/></xsl:if>; + </xsl:when> + <xsl:when test='$stereotype = "array"'> + <xsl:text> + { + sal_uInt32 nCount = </xsl:text> + <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = "arraycount"]/UML:TaggedValue.dataValue'/> + <xsl:text>; + m</xsl:text> + <xsl:value-of select='@name'/> + <xsl:text> = new </xsl:text><xsl:value-of select='$saltype'/><xsl:text>[nCount]; + + for (sal_uInt32 n = 0; n < nCount; ++n) + m</xsl:text><xsl:value-of select='@name'/><xsl:text>[n] = get</xsl:text> + <xsl:value-of select='$type'/> + <xsl:text>(</xsl:text> + <xsl:value-of select='$offset'/> + <xsl:text> + nIndex * sizeof(</xsl:text> + <xsl:value-of select='$saltype'/> + <xsl:text>)); + } + </xsl:text> + </xsl:when> + <xsl:when test='$stereotype = "string"'> + m<xsl:value-of select='@name'/> = getString(<xsl:value-of select='$offset'/>) + </xsl:when> +</xsl:choose> +</xsl:template> + +<xsl:template match="UML:Model" mode="isbooleandffopt"> +<xsl:text> +bool isBooleanDffOpt(sal_uInt32 nId) +{ + bool bResult = false; + + switch (nId) + {
</xsl:text> + <xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="dffopt"]'> + <xsl:if test=".//UML:TagDefinition[@xmi.idref='isbool']"> + <xsl:text> case </xsl:text> + <xsl:variable name="optname"> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref='optname']//UML:TaggedValue.dataValue"/> + </xsl:variable> + <xsl:call-template name="idtoqname"> + <xsl:with-param name="id" select="$optname"/> + </xsl:call-template> + <xsl:text>:
</xsl:text> + </xsl:if> + </xsl:for-each> + <xsl:text> + bResult = true; + break; + + default: + break; + } + + return bResult; +} +</xsl:text> +</xsl:template> + +</xsl:stylesheet> + diff --git a/writerfilter/source/doctok/resourcetools.xsl b/writerfilter/source/doctok/resourcetools.xsl new file mode 100644 index 000000000000..75d124a3eedb --- /dev/null +++ b/writerfilter/source/doctok/resourcetools.xsl @@ -0,0 +1,566 @@ +<!-- +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output method="text" /> + +<xsl:template name='idtoqname'> + <xsl:param name='id'/> + <xsl:text>NS_</xsl:text> + <xsl:value-of select='substring-before($id, ":")'/> + <xsl:text>::LN_</xsl:text> + <xsl:value-of select='substring-after($id, ":")'/> +</xsl:template> + +<xsl:template name="parenttype"> + <xsl:param name='type'/> + <xsl:for-each select='/XMI/XMI.content/UML:Model/UML:Namespace.ownedElement/UML:Generalization[UML:Generalization.child/UML:Class/@xmi.idref=$type]'> + <xsl:value-of select='./UML:Generalization.parent/UML:Class/@xmi.idref'/> + </xsl:for-each> +</xsl:template> + +<xsl:template name='saltype'> + <xsl:param name='type'/> + <xsl:param name='parenttype'/> + <xsl:choose> + <xsl:when test="$type='U8'">sal_uInt8</xsl:when> + <xsl:when test="$type='S8'">sal_Int8</xsl:when> + <xsl:when test="$type='U16'">sal_uInt16</xsl:when> + <xsl:when test="$type='S16'">sal_Int16</xsl:when> + <xsl:when test="$type='U32'">sal_uInt32</xsl:when> + <xsl:when test="$type='S32'">sal_Int32</xsl:when> + <xsl:when test="$type='String'">rtl::OUString</xsl:when> + <xsl:otherwise> + <xsl:text>writerfilter::Reference < </xsl:text> + <xsl:value-of select='$parenttype'/> + <xsl:text> >::Pointer_t</xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template name='typetype'> + <xsl:param name='type'/><xsl:choose> + <xsl:when test="$type='U8'">simple</xsl:when> + <xsl:when test="$type='S8'">simple</xsl:when> + <xsl:when test="$type='U16'">simple</xsl:when> + <xsl:when test="$type='S16'">simple</xsl:when> + <xsl:when test="$type='U32'">simple</xsl:when> + <xsl:when test="$type='S32'">simple</xsl:when> + <xsl:when test="$type='String'">string</xsl:when> + <xsl:when test="$type='Binary'">binary</xsl:when> + <xsl:otherwise>complex</xsl:otherwise> +</xsl:choose> +</xsl:template> + +<xsl:template name="valuetype"> + <xsl:param name="type"/> + <xsl:choose> + <xsl:when test='$type="U8"'>WW8IntValue</xsl:when> + <xsl:when test='$type="S8"'>WW8IntValue</xsl:when> + <xsl:when test='$type="U16"'>WW8IntValue</xsl:when> + <xsl:when test='$type="S16"'>WW8IntValue</xsl:when> + <xsl:when test='$type="U32"'>WW8IntValue</xsl:when> + <xsl:when test='$type="S32"'>WW8IntValue</xsl:when> + <xsl:otherwise>WW8PropertiesValue</xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template match="UML:Attribute" mode="valuetype"> + <xsl:call-template name="valuetype"> + <xsl:with-param name="type" select='.//UML:DataType/@xmi.idref'/> + </xsl:call-template> +</xsl:template> + +<xsl:template name="qnametostrattrs"> + <xsl:text> + /* Attributes */</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noresolve"]'> + </xsl:when> + <xsl:otherwise> + <xsl:text> + mMap[</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>] = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue.dataValue'/> + <xsl:text>";</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + </xsl:for-each> +</xsl:template> + +<xsl:template name="qnametostrops"> + <xsl:text> + /* Operations */</xsl:text> + <xsl:for-each select='.//UML:Operation[@name!="reserved"]'> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noresolve"]'> + </xsl:when> + <xsl:otherwise> + <xsl:text> + mMap[</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>] = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue.dataValue'/> + <xsl:text>";</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + </xsl:for-each> +</xsl:template> + +<xsl:template name="qnametostrclasses"> + <xsl:text> + /* Classes */</xsl:text> + <xsl:for-each select='.//UML:Class[@name!="reserved"]'> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="classid"]'> + <xsl:text> + mMap[</xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>] = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue.dataValue'/> + <xsl:text>";</xsl:text> + </xsl:for-each> + </xsl:for-each> +</xsl:template> + +<xsl:template match='UML:Model' mode='qnametostr'> + <xsl:text> +void QNameToString::init_doctok() +{</xsl:text> +<xsl:call-template name="qnametostrattrs"/> +<xsl:call-template name="qnametostrops"/> +<xsl:call-template name="qnametostrclasses"/> +<xsl:text> +} +</xsl:text> +</xsl:template> + +<xsl:key name="ids" match='UML:Attribute[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]|UML:Operation[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]' use=".//UML:TaggedValue.dataValue"/> + +<xsl:template match="UML:Model" mode="qnametostrfunc"> + <xsl:text> +string qnameToString(sal_uInt32 nToken) +{ + string sResult; + + switch (nToken) + { + // Attributes</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noresolve"]'> + </xsl:when> + <xsl:otherwise> + <xsl:if test="generate-id(key('ids', .//UML:TaggedValue.dataValue)[1])=generate-id(.)"> + <xsl:text> + case </xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>: + sResult = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue.dataValue'/> + <xsl:text>"; + break;</xsl:text> + </xsl:if> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + // Operations</xsl:text> + <xsl:for-each select='.//UML:Operation[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noresolve"]'> + </xsl:when> + <xsl:otherwise> + <xsl:if test="generate-id(key('ids', .//UML:TaggedValue.dataValue)[1])=generate-id(.)"> + <xsl:text> + case </xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>: + sResult = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue.dataValue'/> + <xsl:text>"; + break;</xsl:text> + </xsl:if> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + <xsl:text> + // Classes:</xsl:text> + <xsl:for-each select='.//UML:Class[@name!="reserved"]//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="classid"]'> + <xsl:text> + case </xsl:text> + <xsl:call-template name='idtoqname'> + <xsl:with-param name='id'><xsl:value-of select='.//UML:TaggedValue.dataValue'/></xsl:with-param> + </xsl:call-template> + <xsl:text>: + sResult = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue.dataValue'/> + <xsl:text>"; + break;</xsl:text> + </xsl:for-each> + <xsl:text> + default: + ; + } + + return sResult; +}</xsl:text> +</xsl:template> + +<xsl:template match='UML:Model' mode='sprmcodetostr'> +<xsl:text> +SprmIdToString::SprmIdToString() +{</xsl:text> +<xsl:variable name='tmp'>map < sal_uInt32, string > </xsl:variable> +<xsl:for-each select='.//UML:Class[.//UML:Stereotype/@xmi.idref="ww8sprm"]'> + <xsl:variable name="sprmconst"> + <xsl:call-template name="sprmCodeOfClass"/> + </xsl:variable> + <xsl:text> + mMap[</xsl:text> + <xsl:value-of select="$sprmconst"/> + <xsl:text>] = "</xsl:text> + <xsl:value-of select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="sprmid"]//UML:TaggedValue.dataValue'/> + <xsl:text>";</xsl:text> +</xsl:for-each> +<xsl:text> +} +</xsl:text> +</xsl:template> + +<xsl:key name="classes-with-kind" match="UML:TagDefinition[@xmi.idref='kind']" + use="ancestor::UML:TaggedValue/UML:TaggedValue.dataValue"/> + +<xsl:template name="sprmCodeOfClass"> + <xsl:variable name="tmp"> + <xsl:text>sprm:</xsl:text> + <xsl:value-of select="substring-after(@name, 'sprm')"/> + </xsl:variable> + <xsl:call-template name="idtoqname"> + <xsl:with-param name="id" select="$tmp"/> + </xsl:call-template> +</xsl:template> + +<xsl:template name="sprmkindcase"> + <xsl:param name="kind"/> + <xsl:for-each select="key('classes-with-kind', $kind)/ancestor::UML:Class"> + <xsl:text> + case </xsl:text> + <xsl:call-template name="sprmCodeOfClass"/> + <xsl:text>:</xsl:text> + </xsl:for-each> +</xsl:template> + +<xsl:template match="UML:Model" mode='sprmkind'> +<xsl:text> +Sprm::Kind SprmKind(sal_uInt32 sprmCode) +{ + Sprm::Kind nResult = Sprm::UNKNOWN; + + switch(sprmCode) + {</xsl:text> + <xsl:call-template name="sprmkindcase"> + <xsl:with-param name="kind">paragraph</xsl:with-param> + </xsl:call-template> + <xsl:text> + nResult = Sprm::PARAGRAPH; + break;</xsl:text> + <xsl:call-template name="sprmkindcase"> + <xsl:with-param name="kind">character</xsl:with-param> + </xsl:call-template> + <xsl:text> + nResult = Sprm::CHARACTER; + break;</xsl:text> + <xsl:call-template name="sprmkindcase"> + <xsl:with-param name="kind">table</xsl:with-param> + </xsl:call-template> + <xsl:text> + nResult = Sprm::TABLE; + break;</xsl:text> + <xsl:text> + default: + break; + } + + return nResult; +} +</xsl:text> +</xsl:template> + +<xsl:template match="UML:Model" mode='sprmids'> + <xsl:text> +namespace NS_sprm { </xsl:text> + <xsl:for-each select=".//UML:Class[.//UML:Stereotype/@xmi.idref='ww8sprm']"> + <xsl:variable name="sprmcode"> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = 'sprmcode']/UML:TaggedValue.dataValue"/> + </xsl:variable> + <xsl:variable name="sprmcodelower"> + <xsl:value-of select="translate($sprmcode, 'ABCDEF', 'abcdef')"/> + </xsl:variable> + <xsl:variable name="sprmidname"> + <xsl:text>LN_</xsl:text> + <xsl:value-of select="substring-after(@name, 'sprm')"/> + </xsl:variable> + <xsl:text> + const sal_uInt16 </xsl:text> + <xsl:value-of select="$sprmidname"/> + <xsl:text> = </xsl:text> + <xsl:value-of select="$sprmcodelower"/> + <xsl:text>;</xsl:text> + </xsl:for-each> + <xsl:text> +} +</xsl:text> +</xsl:template> + +<xsl:template match="UML:Model" mode='sprmidsed'> + <xsl:text>#!/bin/sh + cat $1 \
</xsl:text> + <xsl:for-each select=".//UML:Class[.//UML:Stereotype/@xmi.idref='ww8sprm']"> + <xsl:variable name="sprmcode"> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = 'sprmcode']/UML:TaggedValue.dataValue"/> + </xsl:variable> + <xsl:variable name="sprmcodelower"> + <xsl:value-of select="translate($sprmcode, 'ABCDEF', 'abcdef')"/> + </xsl:variable> + <xsl:variable name="sprmidname"> + <xsl:text>NS_sprm::LN_</xsl:text> + <xsl:value-of select="substring-after(@name, 'sprm')"/> + </xsl:variable> + <xsl:text>| sed "s/</xsl:text> +<xsl:value-of select="$sprmcode"/> +<xsl:text>/</xsl:text> +<xsl:value-of select="$sprmidname"/> +<xsl:text>/g" \
</xsl:text> + <xsl:text>| sed "s/</xsl:text> +<xsl:value-of select="$sprmcodelower"/> +<xsl:text>/</xsl:text> +<xsl:value-of select="$sprmidname"/> +<xsl:text>/g" \
</xsl:text> + </xsl:for-each> + <xsl:text> | cat
</xsl:text> +</xsl:template> + +<xsl:template match="UML:Model" mode="sprmidstoxml"> + <xsl:text> +void sprmidsToXML(::std::ostream & out) +{ + </xsl:text> + <xsl:for-each select=".//UML:Class[.//UML:Stereotype/@xmi.idref='ww8sprm']"> + <xsl:variable name="sprmcode"> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = 'sprmcode']/UML:TaggedValue.dataValue"/> + </xsl:variable> + <xsl:variable name="sprmcodelower"> + <xsl:value-of select="translate($sprmcode, 'ABCDEF', 'abcdef')"/> + </xsl:variable> + <xsl:variable name="sprmidname"> + <xsl:text>sprm:</xsl:text> + <xsl:value-of select="substring-after(@name, 'sprm')"/> + </xsl:variable> + <xsl:text> + out << "<theid name=\"</xsl:text> + <xsl:value-of select="$sprmidname"/> + <xsl:text>\"></xsl:text> + <xsl:value-of select="$sprmcodelower"/> + <xsl:text></theid>" << endl;</xsl:text> + </xsl:for-each> + <xsl:text> +} + </xsl:text> +</xsl:template> + +<xsl:template match="UML:Model" mode='sprmreplace'> + <xsl:for-each select=".//UML:Class[.//UML:Stereotype/@xmi.idref='ww8sprm']"> + <xsl:variable name="pattern"> + <xsl:value-of select=".//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref = 'sprmcode']/UML:TaggedValue.dataValue"/> + </xsl:variable> + <xsl:variable name="lowerpattern"> + <xsl:value-of select="translate($pattern, 'ABCDEF', 'abcdef')"/> + </xsl:variable> + <xsl:variable name="upperpattern"> + <xsl:value-of select="translate($pattern, 'abcdef', 'ABCDEF')"/> + </xsl:variable> + <xsl:variable name="tmp"> + <xsl:text>sprm:</xsl:text> + <xsl:value-of select="substring-after(@name, 'sprm')"/> + </xsl:variable> + <xsl:variable name="constname"> + <xsl:call-template name="idtoqname"> + <xsl:with-param name="id" select="$tmp"/> + </xsl:call-template> + </xsl:variable> + <xsl:text> +sed "s/</xsl:text> + <xsl:value-of select="$lowerpattern"/> + <xsl:text>/</xsl:text> + <xsl:value-of select="$constname"/> + <xsl:text>/g" < $1 > $1.out && mv $1.out $1 </xsl:text> + <xsl:text> +sed "s/</xsl:text> + <xsl:value-of select="$upperpattern"/> + <xsl:text>/</xsl:text> + <xsl:value-of select="$constname"/> + <xsl:text>/g" < $1 > $1.out && mv $1.out $1 </xsl:text> + </xsl:for-each> + <xsl:text>
</xsl:text> +</xsl:template> + +<!-- Key all attributes with the same name and same value --> +<xsl:key name="same-valued-tagged-data" + match="UML:TaggedValue.dataValue" use="." /> + +<xsl:template name="analyzerdoctokidsattrs"> + <xsl:text> + /* Attributes */</xsl:text> + <xsl:for-each select='.//UML:Attribute[@name!="reserved"]'> + <xsl:if test='count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0'> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="attrid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text> + out << "<theid name=\"</xsl:text> + <xsl:value-of select=".//UML:TaggedValue.dataValue"/> + <xsl:text>\"></xsl:text> + <xsl:value-of select='10000 + position()'/> + <xsl:text></theid>" << endl;</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + </xsl:if> + </xsl:for-each> +</xsl:template> + +<xsl:template name="analyzerdoctokidsops"> + <xsl:text> + /* Operations */</xsl:text> + <xsl:for-each select='.//UML:Operation[@name!="reserved"]'> + <xsl:if test='count(.//UML:Stereotype[@xmi.idref="noqname"]) = 0'> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="opid"]'> + <xsl:choose> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text> + out << "<theid name=\"</xsl:text> + <xsl:value-of select=".//UML:TaggedValue.dataValue"/> + <xsl:text>\"></xsl:text> + <xsl:value-of select='20000 + position()'/> + <xsl:text></theid>" << endl;</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + </xsl:if> + </xsl:for-each> +</xsl:template> + +<xsl:template name="analyzerdoctokidsclasses"> + <xsl:text> + /* clases */</xsl:text> + <xsl:for-each select='.//UML:Class[@name!="reserved"]'> + <xsl:for-each select='.//UML:TaggedValue[.//UML:TagDefinition/@xmi.idref="classid"]'> + <xsl:choose> + <xsl:when test='.//UML:Stereotype[@xmi.idref="noqname"]'/> + <xsl:when test='generate-id(UML:TaggedValue.dataValue) != generate-id(key("same-valued-tagged-data", UML:TaggedValue.dataValue)[1])'/> + <xsl:otherwise> + <xsl:text> + out << "<theid name=\"</xsl:text> + <xsl:value-of select=".//UML:TaggedValue.dataValue"/> + <xsl:text>\"></xsl:text> + <xsl:value-of select='30000 + position()'/> + <xsl:text></theid>" << endl;</xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> + </xsl:for-each> +</xsl:template> + +<xsl:template match="UML:Model" mode="analyzerdoctokids"> + <xsl:text> +void doctokidsToXML(::std::ostream & out) +{</xsl:text> +<xsl:call-template name="analyzerdoctokidsattrs"/> +<xsl:call-template name="analyzerdoctokidsops"/> +<xsl:call-template name="analyzerdoctokidsclasses"/> +<xsl:text> +} + </xsl:text> +</xsl:template> + + <xsl:template name="licenseheader"> + <xsl:text> +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * http://www.openoffice.org/license.html + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +/* + + THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT! + +*/ +
</xsl:text> + </xsl:template> +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/sprmcodetostr.xsl b/writerfilter/source/doctok/sprmcodetostr.xsl new file mode 100644 index 000000000000..98cf02919959 --- /dev/null +++ b/writerfilter/source/doctok/sprmcodetostr.xsl @@ -0,0 +1,39 @@ +<!-- +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output method="text" /> + +<xsl:include href="resourcetools.xsl"/> + +<xsl:template match="/"> + <xsl:apply-templates select=".//UML:Model" mode="sprmcodetostr"/> +</xsl:template> +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/sprmids.xsl b/writerfilter/source/doctok/sprmids.xsl new file mode 100644 index 000000000000..2ca8826e94dc --- /dev/null +++ b/writerfilter/source/doctok/sprmids.xsl @@ -0,0 +1,82 @@ +<!-- +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> + <xsl:output method="text" /> + + <xsl:include href="resourcetools.xsl"/> + + <xsl:template match="/"> + <out> + <xsl:text> +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * http://www.openoffice.org/license.html + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +/* + + THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT! + +*/ +#ifndef INCLUDED_SPRMIDS +#define INCLUDED_SPRMIDS + +#include <sal/types.h> + +</xsl:text> +<xsl:apply-templates select=".//UML:Model" mode="sprmids"/> +<xsl:text> + +#endif // INCLUDED_SPRMIDS
</xsl:text> + </out> + </xsl:template> +</xsl:stylesheet> diff --git a/writerfilter/source/doctok/tidyxmi.xsl b/writerfilter/source/doctok/tidyxmi.xsl new file mode 100644 index 000000000000..6371fb05b696 --- /dev/null +++ b/writerfilter/source/doctok/tidyxmi.xsl @@ -0,0 +1,120 @@ +<!-- +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ +--> +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output indent="yes"/> +<xsl:template match="/"> +<XMI xmi.version="1.2"> + <XMI.header> + <XMI.documentation/> + </XMI.header> + <XMI.content> + <UML:Model xmlns:UML="org.omg.xmi.namespace.UML" name="WW8Document" > + <UML:Namespace.ownedElement> + <xsl:apply-templates select="XMI/XMI.content/UML:Model/UML:Namespace.ownedElement"/> + </UML:Namespace.ownedElement> + </UML:Model> + </XMI.content> +</XMI> + +</xsl:template> + +<xsl:template match="UML:Namespace.ownedElement"> + <xsl:comment>Stereotypes </xsl:comment> + <xsl:copy-of select="UML:Stereotype"/> + <xsl:comment>Stereotypes</xsl:comment> + <xsl:comment>Datatypes </xsl:comment> + <xsl:copy-of select="UML:DataType"/> + <xsl:comment>Datatypes</xsl:comment> + <xsl:comment>Tag definitions </xsl:comment> + <xsl:copy-of select="UML:TagDefinition"/> + <xsl:comment>Tag definitions </xsl:comment> + <xsl:comment>Classes without stereotype</xsl:comment> + <xsl:apply-templates select="UML:Class[count(./UML:ModelElement.stereotype) = 0]"/> + <xsl:comment>Classes without stereotype</xsl:comment> + <xsl:comment>Resources</xsl:comment> + <xsl:copy-of select="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='resource']"/> + <xsl:comment>Resources</xsl:comment> + <xsl:comment>WW8 resources</xsl:comment> + <xsl:apply-templates select="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8resource' and count(UML:ModelElement.stereotype/UML:Stereotype[@xmi.idref='ww8sprm']) = 0]"/> + <xsl:comment>WW8 resources</xsl:comment> + <xsl:comment>SPRMS</xsl:comment> + <xsl:apply-templates select="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8sprm']"/> + <xsl:comment>SPRMS</xsl:comment> + <xsl:comment>DFFS</xsl:comment> + <xsl:apply-templates select="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='dffrecord']"/> + <xsl:comment>DFFS</xsl:comment> + <xsl:comment>DFFOPT</xsl:comment> + <xsl:apply-templates select="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='dffopt']"/> + <xsl:comment>DFFOPT</xsl:comment> +</xsl:template> + +<xsl:key name="generalization" match="UML:Generalization" + use="UML:Generalization.child/UML:Class/@xmi.idref"/> + +<xsl:template match="UML:Class[count(UML:ModelElement.stereotype) = 0]"> + <xsl:variable name="theid"><xsl:value-of select="@xmi.id"/></xsl:variable> + <xsl:comment>Class <xsl:value-of select="@xmi.id"/></xsl:comment> + <xsl:copy-of select="."/> + <xsl:copy-of select="key('generalization', $theid)"/> + <xsl:comment>Class <xsl:value-of select="@xmi.id"/></xsl:comment> +</xsl:template> + +<xsl:template match="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8resource' and count(UML:ModelElement.stereotype/UML:Stereotype[@xmi.idref='ww8sprm']) = 0]"> + <xsl:variable name="theid"><xsl:value-of select="@xmi.id"/></xsl:variable> + <xsl:comment>Class <xsl:value-of select="@xmi.id"/></xsl:comment> + <xsl:copy-of select="."/> + <xsl:copy-of select="key('generalization', $theid)"/> + <xsl:comment>Class <xsl:value-of select="@xmi.id"/></xsl:comment> +</xsl:template> + +<xsl:template match="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='ww8sprm']"> + <xsl:variable name="theid"><xsl:value-of select="@xmi.id"/></xsl:variable> + <xsl:comment>SPRM <xsl:value-of select="@xmi.id"/></xsl:comment> + <xsl:copy-of select="."/> + <xsl:copy-of select="key('generalization', $theid)"/> + <xsl:comment>SPRM <xsl:value-of select="@xmi.id"/></xsl:comment> +</xsl:template> + +<xsl:template match="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='dffrecord']"> + <xsl:variable name="theid"><xsl:value-of select="@xmi.id"/></xsl:variable> + <xsl:comment>DFF <xsl:value-of select="@xmi.id"/></xsl:comment> + <xsl:copy-of select="."/> + <xsl:copy-of select="key('generalization', $theid)"/> + <xsl:comment>DFF <xsl:value-of select="@xmi.id"/></xsl:comment> +</xsl:template> + +<xsl:template match="UML:Class[UML:ModelElement.stereotype/UML:Stereotype/@xmi.idref='dffopt']"> + <xsl:variable name="theid"><xsl:value-of select="@xmi.id"/></xsl:variable> + <xsl:comment>DFFOPT <xsl:value-of select="@xmi.id"/></xsl:comment> + <xsl:copy-of select="."/> + <xsl:copy-of select="key('generalization', $theid)"/> + <xsl:comment>DFFOPT <xsl:value-of select="@xmi.id"/></xsl:comment> +</xsl:template> + +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/xmigen.el b/writerfilter/source/doctok/xmigen.el new file mode 100644 index 000000000000..c85299604374 --- /dev/null +++ b/writerfilter/source/doctok/xmigen.el @@ -0,0 +1,126 @@ +(defun insert-uml-class-begin (name) + (insert "<UML:Class xmi.id=\"" name "\" name=\"" name "\">\n")) + +(defun insert-uml-class-end () + (insert "</UML:Class>\n")) + +(defun insert-uml-stereotype (stereotype) + (insert "<UML:ModelElement.stereotype>\n") + (insert " <UML:Stereotype xmi.idref=\"" stereotype "\"/>\n") + (insert "</UML:ModelElement.stereotype>\n")) + + +(defun insert-uml-taggedvalue (value type) + (insert " <UML:ModelElement.taggedValue>\n") + (insert " <UML:TaggedValue>\n") + (insert " <UML:TaggedValue.dataValue>" value "</UML:TaggedValue.dataValue>\n") + (insert " <UML:TaggedValue.type>\n") + (insert " <UML:TagDefinition xmi.idref=\"" type "\"/>\n") + (insert " </UML:TaggedValue.type>\n") + (insert " </UML:TaggedValue>\n") + (insert " </UML:ModelElement.taggedValue>\n")) + +(defun insert-uml-attribute (type name offset bits mask shift comment attrid) + (insert "<UML:Classifier.feature>\n") + (insert " <UML:Attribute name=\"" name "\">\n") + (insert-uml-taggedvalue comment "comment") + (insert-uml-taggedvalue offset "offset") + (insert-uml-taggedvalue bits "bits") + (insert-uml-taggedvalue mask "mask") + (insert-uml-taggedvalue shift "shift") + (insert-uml-taggedvalue attrid "attrid") + (insert " <UML:StructuralFeature.type>\n") + (insert " <UML:DataType xmi.idref=\"" type "\"/>\n") + (insert " </UML:StructuralFeature.type>\n") + (insert " <UML:ModelElement.stereotype>\n") + (insert " <UML:Stereotype xmi.idref=\"attribute\"/>\n") + (insert " </UML:ModelElement.stereotype>\n") + (insert " </UML:Attribute>\n") + (insert "</UML:Classifier.feature>\n")) + +(defun insert-uml-attribute-array (type arraycount name offset bits mask shift comment attrid) + (insert "<UML:Classifier.feature>\n") + (insert " <UML:Attribute name=\"" name "\">\n") + (insert-uml-taggedvalue comment "comment") + (insert-uml-taggedvalue offset "offset") + (insert-uml-taggedvalue bits "bits") + (insert-uml-taggedvalue mask "mask") + (insert-uml-taggedvalue shift "shift") + (insert-uml-taggedvalue attrid "attrid") + (insert-uml-taggedvalue arraycount "arraycount") + (insert " <UML:StructuralFeature.type>\n") + (insert " <UML:DataType xmi.idref=\"" type "\"/>\n") + (insert " </UML:StructuralFeature.type>\n") + (insert " <UML:ModelElement.stereotype>\n") + (insert " <UML:Stereotype xmi.idref=\"array\"/>\n") + (insert " </UML:ModelElement.stereotype>\n") + (insert " </UML:Attribute>\n") + (insert "</UML:Classifier.feature>\n")) + +(defun insert-uml-operation (type name comment opid) + (insert "<UML:Classifier.feature>\n") + (insert " <UML:Operation name=\"" name "\" >\n") + (insert-uml-taggedvalue opid "opid") + (insert " <UML:BehavioralFeature.parameter>\n") + (insert " <UML:Parameter kind=\"return\" name=\"return\">\n") + (insert " <UML:Parameter.type>\n") + (insert " <UML:Class xmi.idref=\"" type "\" />\n") + (insert " </UML:Parameter.type>\n") + (insert " </UML:Parameter>\n") + (insert " </UML:BehavioralFeature.parameter>\n") + (insert " <UML:ModelElement.stereotype>\n") + (insert " <UML:Stereotype xmi.idref=\"attribute\" />\n") + (insert " </UML:ModelElement.stereotype>\n") + (insert " </UML:Operation>\n") + (insert "</UML:Classifier.feature>\n")) + +(defun insert-uml-binary (name comment opid) + (insert "<UML:Classifier.feature>\n") + (insert " <UML:Operation name=\"" name "\" >\n") + (insert-uml-taggedvalue opid "opid") + (insert " <UML:BehavioralFeature.parameter>\n") + (insert " <UML:Parameter kind=\"return\" name=\"return\">\n") + (insert " <UML:Parameter.type>\n") + (insert " <UML:Class xmi.idref=\"Binary\" />\n") + (insert " </UML:Parameter.type>\n") + (insert " </UML:Parameter>\n") + (insert " </UML:BehavioralFeature.parameter>\n") + (insert " <UML:ModelElement.stereotype>\n") + (insert " <UML:Stereotype xmi.idref=\"binary\" />\n") + (insert " </UML:ModelElement.stereotype>\n") + (insert " </UML:Operation>\n") + (insert "</UML:Classifier.feature>\n")) + +(defun insert-uml-operation-array (type name comment opid) + (insert "<UML:Classifier.feature>\n") + (insert " <UML:Operation name=\"" name "\" >\n") + (insert-uml-taggedvalue opid "opid") + (insert " <UML:BehavioralFeature.parameter>\n") + (insert " <UML:Parameter kind=\"return\" name=\"return\">\n") + (insert " <UML:Parameter.type>\n") + (insert " <UML:Class xmi.idref=\"" type "\" />\n") + (insert " </UML:Parameter.type>\n") + (insert " </UML:Parameter>\n") + (insert " </UML:BehavioralFeature.parameter>\n") + (insert " <UML:ModelElement.stereotype>\n") + (insert " <UML:Stereotype xmi.idref=\"array\" />\n") + (insert " </UML:ModelElement.stereotype>\n") + (insert " </UML:Operation>\n") + (insert "</UML:Classifier.feature>\n")) + +(defun insert-uml-generalization (parent child) + (insert "<UML:Generalization isSpecification=\"false\" xmi.id=\"" child "-" parent "\" >\n") + (insert " <UML:Generalization.child>\n") + (insert " <UML:Class xmi.idref=\"" child "\" />\n") + (insert " </UML:Generalization.child>\n") + (insert " <UML:Generalization.parent>\n") + (insert " <UML:Class xmi.idref=\"" parent "\" />\n") + (insert " </UML:Generalization.parent>\n") + (insert "</UML:Generalization>\n")) + +(defun insert-uml-sprm (name sprmcode kind) + (insert-uml-class-begin name) + (insert-uml-stereotype "ww8sprm") + (insert-uml-taggedvalue sprmcode "sprmcode") + (insert-uml-taggedvalue (concat "rtf:" name) "sprmid") + (insert-uml-taggedvalue kind "kind"))
\ No newline at end of file diff --git a/writerfilter/source/doctok/xmigen.xsl b/writerfilter/source/doctok/xmigen.xsl new file mode 100644 index 000000000000..f184dcfed4d2 --- /dev/null +++ b/writerfilter/source/doctok/xmigen.xsl @@ -0,0 +1,577 @@ +<!-- +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: resources.xsl,v $ + * + * $Revision: 1.9 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +--> +<xsl:stylesheet version="1.0" + xmlns:xsl="http://www.w3.org/1999/XSL/Transform" + xmlns:UML = 'org.omg.xmi.namespace.UML' + xml:space="default"> + <xsl:output method="xml"/> + + <xsl:template match="/"> + <out> + <xsl:apply-templates select="*"/> + </out> + </xsl:template> + + <xsl:template name="calcsizeinner"> + <xsl:param name="size">0</xsl:param> + <xsl:variable name="arraycount"> + <xsl:choose> + <xsl:when test="@array-count"> + <xsl:value-of select="@array-count"/> + </xsl:when> + <xsl:otherwise>1</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="mysize"> + <xsl:choose> + <xsl:when test="@size and not(@offset)"> + <xsl:value-of select="number($arraycount) * number(@size)"/> + </xsl:when> + <xsl:otherwise>0</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:choose> + <xsl:when test="following-sibling::*"> + <xsl:for-each select="following-sibling::*[1]"> + <xsl:call-template name="calcsizeinner"> + <xsl:with-param name="size" + select="number($size) + number($mysize)"/> + </xsl:call-template> + </xsl:for-each> + </xsl:when> + <xsl:otherwise> + <xsl:value-of select="number($size) + number($mysize)"/> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template name="calcsize"> + <xsl:for-each select="*[1]"> + <xsl:call-template name="calcsizeinner"/> + </xsl:for-each> + </xsl:template> + + <xsl:template name="calcoffsetinner"> + <xsl:variable name="arraycount"> + <xsl:choose> + <xsl:when test="@array-count"> + <xsl:value-of select="@array-count"/> + </xsl:when> + <xsl:otherwise>1</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:variable name="mysize"> + <xsl:choose> + <xsl:when test="@size and not(@offset)"> + <xsl:value-of select="number($arraycount) * number(@size)"/> + </xsl:when> + <xsl:otherwise>0</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <xsl:choose> + <xsl:when test="preceding-sibling::*"> + <xsl:variable name="precedingoffset"> + <xsl:for-each select="preceding-sibling::*[1]"> + <xsl:call-template name="calcoffsetinner"/> + </xsl:for-each> + </xsl:variable> + <xsl:value-of select="number($precedingoffset) + number($mysize)"/> + </xsl:when> + <xsl:otherwise> + <xsl:value-of select="$mysize"/> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template name="calcoffset"> + <xsl:choose> + <xsl:when test="@offset"> + <xsl:value-of select="@offset"/> + </xsl:when> + <xsl:otherwise> + <xsl:for-each select="preceding-sibling::*[1]"> + <xsl:call-template name="calcoffsetinner"/> + </xsl:for-each> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template match="ww8resource"> + <UML:Class> + <xsl:attribute name="xmi.id"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + <xsl:for-each select="stereotype"> + <UML:ModelElement.stereotype> + <UML:Stereotype> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="@name"/> + </xsl:attribute> + </UML:Stereotype> + </UML:ModelElement.stereotype> + </xsl:for-each> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:call-template name="calcsize"/> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="size"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + + <xsl:apply-templates select="*"/> + + </UML:Class> + <UML:Generalization isSpecification="false"> + <xsl:attribute name="xmi.id"> + <xsl:value-of select="@name"/> + <xsl:text>-</xsl:text> + <xsl:value-of select="@resource"/> + </xsl:attribute> + <UML:Generalization.child> + <UML:Class> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="@name"/> + </xsl:attribute> + </UML:Class> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="@resource"/> + </xsl:attribute> + </UML:Class> + </UML:Generalization.parent> + </UML:Generalization> + </xsl:template> + + <xsl:template match="sprm"> + <xsl:variable name="isww8resource"> + <xsl:choose> + <xsl:when test="count(*) > 0">YES</xsl:when> + <xsl:otherwise>NO</xsl:otherwise> + </xsl:choose> + </xsl:variable> + <UML:Class> + <xsl:attribute name="xmi.id"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:if test="$isww8resource='YES'"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8resource"/> + </UML:ModelElement.stereotype> + </xsl:if> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="ww8sprm"/> + </UML:ModelElement.stereotype> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">sprmcode</xsl:with-param> + <xsl:with-param name="value" select="@code"/> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">sprmid</xsl:with-param> + <xsl:with-param name="value" select="@token"/> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">kind</xsl:with-param> + <xsl:with-param name="value" select="@kind"/> + </xsl:call-template> + <xsl:apply-templates select="*"/> + </UML:Class> + <xsl:if test="$isww8resource='YES'"> + <xsl:call-template name="generalization"> + <xsl:with-param name="parent">Properties</xsl:with-param> + <xsl:with-param name="child" select="@name"/> + </xsl:call-template> + </xsl:if> + </xsl:template> + + <xsl:template name="generalization"> + <xsl:param name="parent"/> + <xsl:param name="child"/> + <UML:Generalization isSpecification="false"> + <xsl:attribute name="xmi.id"> + <xsl:value-of select="$child"/> + <xsl:text>-</xsl:text> + <xsl:value-of select="$parent"/> + </xsl:attribute> + <UML:Generalization.child> + <UML:Class> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="$child"/> + </xsl:attribute> + </UML:Class> + </UML:Generalization.child> + <UML:Generalization.parent> + <UML:Class xmi.idref="Properties"> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="$parent"/> + </xsl:attribute> + </UML:Class> + </UML:Generalization.parent> + </UML:Generalization> + </xsl:template> + + <xsl:template name="taggedvalue"> + <xsl:param name="type"/> + <xsl:param name="value"/> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:value-of select="$value"/> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="$type"/> + </xsl:attribute> + </UML:TagDefinition> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + </xsl:template> + + <xsl:template match="attribute"> + <UML:Classifier.feature> + <UML:Attribute> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">comment</xsl:with-param> + <xsl:with-param name="value"/> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">offset</xsl:with-param> + <xsl:with-param name="value"> + <xsl:call-template name="calcoffset"/> + </xsl:with-param> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">shift</xsl:with-param> + <xsl:with-param name="value"></xsl:with-param> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">mask</xsl:with-param> + <xsl:with-param name="value"></xsl:with-param> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">bits</xsl:with-param> + <xsl:with-param name="value"></xsl:with-param> + </xsl:call-template> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">attrid</xsl:with-param> + <xsl:with-param name="value"> + <xsl:choose> + <xsl:when test="@token"> + <xsl:value-of select="@token"/> + </xsl:when> + <xsl:otherwise> + <xsl:text>rtf:</xsl:text> + <xsl:value-of select="@name"/> + </xsl:otherwise> + </xsl:choose> + </xsl:with-param> + </xsl:call-template> + <xsl:if test="@array-count"> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">arraycount</xsl:with-param> + <xsl:with-param name="value"> + <xsl:value-of select="@array-count"/> + </xsl:with-param> + </xsl:call-template> + </xsl:if> + <UML:StructuralFeature.type> + <UML:DataType> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="@type"/> + </xsl:attribute> + </UML:DataType> + </UML:StructuralFeature.type> + <xsl:choose> + <xsl:when test="@array-count"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </xsl:when> + <xsl:otherwise> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </xsl:otherwise> + </xsl:choose> + </UML:Attribute> + </UML:Classifier.feature> + </xsl:template> + + <xsl:template match="bitfield"> + <xsl:variable name="offset"> + <xsl:call-template name="calcoffset"/> + </xsl:variable> + <xsl:for-each select="bits"> + <xsl:call-template name="bits"> + <xsl:with-param name="offset" select="$offset"/> + </xsl:call-template> + </xsl:for-each> + </xsl:template> + + <xsl:template name="mask"> + <xsl:param name="count"/> + <xsl:param name="value"/> + + <xsl:choose> + <xsl:when test="number($count) = 1"> + <xsl:value-of select="$value"/> + </xsl:when> + <xsl:otherwise> + <xsl:call-template name="mask"> + <xsl:with-param name="count" select="number($count) - 1"/> + <xsl:with-param name="value" select="number($value) * 2 + 1"/> + </xsl:call-template> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template name="shift"> + <xsl:param name="shift"/> + <xsl:param name="value"/> + + <xsl:choose> + <xsl:when test="number($shift) = 0"> + <xsl:value-of select="$value"/> + </xsl:when> + <xsl:otherwise> + <xsl:call-template name="shift"> + <xsl:with-param name="shift" select="number($shift) - 1"/> + <xsl:with-param name="value" select="$value * 2"/> + </xsl:call-template> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template name='dectohex'> + <xsl:param name="number"/> + <xsl:if test="$number > 16"> + <xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="floor($number div 16)"/> + </xsl:call-template> + </xsl:if> + <xsl:value-of select="substring('0123456789abcdef', $number mod 16 + 1, 1)"/> + </xsl:template> + + <xsl:template name="calcshift"> + <xsl:choose> + <xsl:when test="@shift"> + <xsl:value-of select="@shift"/> + </xsl:when> + <xsl:otherwise> + <xsl:value-of select="sum(following-sibling::*[not (@shift)]/@bits)"/> + </xsl:otherwise> + </xsl:choose> + </xsl:template> + + <xsl:template name="bits"> + <xsl:param name="offset"/> + <xsl:variable name="shift"> + <xsl:call-template name="calcshift"/> + </xsl:variable> + <xsl:variable name="mask"> + <xsl:call-template name="mask"> + <xsl:with-param name="count" select="@bits"/> + <xsl:with-param name="value" select="1"/> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="maskshifted"> + <xsl:call-template name="shift"> + <xsl:with-param name="shift" select="$shift"/> + <xsl:with-param name="value" select="$mask"/> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="maskhex"> + <xsl:text>0x</xsl:text> + <xsl:call-template name="dectohex"> + <xsl:with-param name="number" select="$maskshifted"/> + </xsl:call-template> + </xsl:variable> + <UML:Classifier.feature> + <UML:Attribute> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue/> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="comment"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:value-of select="$offset"/> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="offset"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:value-of select="$shift"/> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="shift"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:value-of select="$maskhex"/> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="mask"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:value-of select="@bits"/> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="bits"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:ModelElement.taggedValue> + <UML:TaggedValue> + <UML:TaggedValue.dataValue> + <xsl:choose> + <xsl:when test="@token"> + <xsl:value-of select="@token"/> + </xsl:when> + <xsl:otherwise> + <xsl:text>rtf:</xsl:text> + <xsl:value-of select="@name"/> + </xsl:otherwise> + </xsl:choose> + </UML:TaggedValue.dataValue> + <UML:TaggedValue.type> + <UML:TagDefinition xmi.idref="attrid"/> + </UML:TaggedValue.type> + </UML:TaggedValue> + </UML:ModelElement.taggedValue> + <UML:StructuralFeature.type> + <UML:DataType> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="ancestor::bitfield/@type"/> + </xsl:attribute> + </UML:DataType> + </UML:StructuralFeature.type> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </UML:Attribute> + </UML:Classifier.feature> + </xsl:template> + + <xsl:template match="operation"> + <UML:Classifier.feature> + <UML:Operation> + <xsl:attribute name="name"> + <xsl:value-of select="@name"/> + </xsl:attribute> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">opid</xsl:with-param> + <xsl:with-param name="value"> + <xsl:choose> + <xsl:when test="@token"> + <xsl:value-of select="@token"/> + </xsl:when> + <xsl:otherwise> + <xsl:text>rtf:</xsl:text> + <xsl:value-of select="@name"/> + </xsl:otherwise> + </xsl:choose> + </xsl:with-param> + </xsl:call-template> + <xsl:if test="@array-count"> + <xsl:call-template name="taggedvalue"> + <xsl:with-param name="type">arraycount</xsl:with-param> + <xsl:with-param name="value"> + <xsl:value-of select="@array-count"/> + </xsl:with-param> + </xsl:call-template> + </xsl:if> + <UML:BehavioralFeature.parameter> + <UML:Parameter kind="return" name="return"> + <UML:Parameter.type> + <UML:Class> + <xsl:attribute name="xmi.idref"> + <xsl:value-of select="@type"/> + </xsl:attribute> + </UML:Class> + </UML:Parameter.type> + </UML:Parameter> + </UML:BehavioralFeature.parameter> + <xsl:choose> + <xsl:when test="@array-count or stereotype[text()='array']"> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="array"/> + </UML:ModelElement.stereotype> + </xsl:when> + <xsl:otherwise> + <UML:ModelElement.stereotype> + <UML:Stereotype xmi.idref="attribute"/> + </UML:ModelElement.stereotype> + </xsl:otherwise> + </xsl:choose> + </UML:Operation> + </UML:Classifier.feature> + </xsl:template> +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/xmistat.xsl b/writerfilter/source/doctok/xmistat.xsl new file mode 100644 index 000000000000..842e0f0361e2 --- /dev/null +++ b/writerfilter/source/doctok/xmistat.xsl @@ -0,0 +1,37 @@ +/************************************************************************* + * + DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + + Copyright 2000, 2010 Oracle and/or its affiliates. + + OpenOffice.org - a multi-platform office productivity suite + + This file is part of OpenOffice.org. + + OpenOffice.org is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + OpenOffice.org is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details + (a copy is included in the LICENSE file that accompanied this code). + + You should have received a copy of the GNU Lesser General Public License + version 3 along with OpenOffice.org. If not, see + <http://www.openoffice.org/license.html> + for a copy of the LGPLv3 License. + + ************************************************************************/ + +<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:UML = 'org.omg.xmi.namespace.UML' xml:space="default"> +<xsl:output indent="yes"/> +<xsl:template match="/"> + <xsl:for-each select="//UML:Class[@xmi.id]"> + <xsl:value-of select="@xmi.id"/> + <xsl:text>
</xsl:text> + </xsl:for-each> + <xsl:value-of select="count(//UML:Class)"/> +</xsl:template> +</xsl:stylesheet>
\ No newline at end of file diff --git a/writerfilter/source/doctok/xmitocpp b/writerfilter/source/doctok/xmitocpp new file mode 100755 index 000000000000..ec06b400eb80 --- /dev/null +++ b/writerfilter/source/doctok/xmitocpp @@ -0,0 +1,34 @@ +#!/bin/tcsh +#************************************************************************ +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +# ***********************************************************************/ + +xalan -xsl qnametostr.xsl -in resources.xmi > qnametostr.tmp +xalan -xsl sprmcodetostr.xsl -in resources.xmi > sprmcodetostr.tmp +xalan -xsl resources.xsl -in resources.xmi > resources.hxx +xalan -xsl resourcesimpl.xsl -in resources.xmi > resources.cxx +xalan -xsl resourceids.xsl -in resources.xmi > ../../inc/doctok/resourceids.hxx +xalan -xsl sprmids.xsl -in resources.xmi > ../../inc/resourcemodel/sprmids.hxx |