// Methods
public ShadingType3(PDFDirect d) : base(d)
{
this.mCoords = null;
this.mStartCoord = null;
this.mEndCoord = null;
this.mExtend = null;
}
private static Resource CreateResource(PDFDirect d, Type resType)
{
MethodInfo info1;
object[] objArray1;
try
{
while (!resType.Equals(typeof(object)))
{
if (resType.Equals(typeof(Resource)))
{
return(null);
}
if (!resType.IsSubclassOf(typeof(Resource)))
{
throw new ArgumentException("Resources should derive from Altsoft.PDFO.Resource", "resType");
}
info1 = resType.GetMethod("Factory", (BindingFlags.NonPublic | (BindingFlags.Public | BindingFlags.Static)));
if (info1 == null)
{
resType = resType.BaseType;
continue;
}
objArray1 = new object[1];
objArray1[0] = ((object)d);
return((Resource)info1.Invoke(null, objArray1));
}
}
catch (TargetInvocationException exception1)
{
throw exception1.InnerException;
}
throw new ArgumentException("Resources should have static method with signature (PDFDirect)", "resType");
}
public PDFIndirect New(PDFDirect dir)
{
PDFIndirect indirect1 = this.New();
indirect1.Direct = dir;
return(indirect1);
}
internal static PDFObject TreatNewCollectionObject(PDFDirect collection, PDFObject o)
{
if (!o.IsIndirect)
{
if (o.Parent != null)
{
o = ((PDFObject)o.Clone());
}
if (o.PDFType == PDFObjectType.tPDFStream)
{
if (collection.Doc != null)
{
o = collection.Doc.Indirects.New(o.Direct);
}
else
{
o = Library.CreateIndirect(o.Direct);
}
}
o.Parent = collection;
return(o);
}
if (((o.Doc != collection.Doc) && (o.Doc != null)) && (collection.Doc != null))
{
throw new InvalidOperationException("Can not connect objects from different documents");
}
if ((o.Doc == null) && (collection.Doc != null))
{
((CorePDFObject)o.Indirect).SetDocument(collection.Doc);
}
return(o.Indirect);
}
public PDFDirect DetachDirect()
{
PDFDirect direct1 = this.Direct;
this.mDirect = CorePDFNull.Instance;
return(direct1);
}
public Shading(PDFDirect d) : base(d)
{
this.mColorSpace = null;
this.mBackground = null;
this.mBBox = null;
this.mFunction = null;
}
public static Resource Factory(PDFDirect direct)
{
if (direct == null)
{
return(null);
}
string text1 = ((direct as PDFDict)["S"] as PDFName).Value;
if (text1 == null)
{
goto Label_0056;
}
text1 = string.IsInterned(text1);
if (text1 != "MR")
{
if (text1 == "SR")
{
goto Label_004F;
}
goto Label_0056;
}
return(new RenditionMedia(direct));
Label_004F:
return(new RenditionSelector(direct));
Label_0056:
return(null);
}
// Methods
public ArticleBead(PDFDirect direct) : base(direct)
{
this.mThread = null;
this.mNextBead = null;
this.mPrevBead = null;
this.mBeadRect = null;
}
private void Create()
{
XRefEntry entry1 = new XRefEntry();
entry1.dirty = false;
entry1.type = 0;
entry1.generation = 65535;
entry1.indirect = null;
entry1.offset = ((long)0);
this.mXRef.Add(entry1);
this.mRoot = Library.CreateDict();
this.Indirects.New().Direct = this.mRoot;
this.mRoot["Type"] = Library.CreateName("Catalog");
PDFObject obj1 = this.Indirects.New();
this.mRoot["Pages"] = obj1;
PDFDirect direct1 = Library.CreateDict();
obj1.Direct = direct1;
PDFDict dict1 = ((PDFDict)direct1);
dict1["Type"] = Library.CreateName("Pages");
dict1["Count"] = Library.CreateInteger(((long)0));
dict1["Kids"] = Library.CreateArray(0);
this.mInfo = Library.CreateDict();
this.mTrailer = Library.CreateDict();
this.mTrailer["Root"] = this.Indirects.New(this.mRoot);
this.mTrailer["Info"] = this.Indirects.New(this.mInfo);
}
public static PDFIndirect CreateIndirect(PDFDirect direct)
{
PDFIndirect indirect1 = Library.Instance._CreateIndirect();
indirect1.Direct = direct;
return(indirect1);
}
internal static Resource Factory(PDFDirect d)
{
PDFName name1;
PDFDict dict1 = (d as PDFStream).Dict;
string text1 = (dict1["Subtype"] as PDFName).Value;
if (text1 == "Image")
{
return(new XObjectImage(d));
}
if (text1 == "Form")
{
name1 = (dict1["SubType2"] as PDFName);
if (name1 == null)
{
return(new XObjectForm(d));
}
if (name1.Value == "PS")
{
return(new XObjectPS(d));
}
return(new XObjectForm(d));
}
if (text1 == "PS")
{
return(new XObjectPS(d));
}
throw new PDFSyntaxException(d, "Invalid XObject type");
}
internal static Resource Factory(PDFDirect d)
{
PDFObjectType type1 = d.PDFType;
switch (type1)
{
case PDFObjectType.tPDFDict:
{
goto Label_0024;
}
case PDFObjectType.tPDFArray:
{
goto Label_002B;
}
case PDFObjectType.tPDFStream:
{
goto Label_001D;
}
}
goto Label_002B;
Label_001D:
return(new PatternTiling(d));
Label_0024:
return(new PatternShading(d));
Label_002B:
throw new PDFSyntaxException(d, "Invalid Pattern");
}
// Methods
public FontType3(PDFDirect d) : base(d)
{
int num1;
PDFNumeric numeric1;
PDFArray array1 = (this.Dict["FontMatrix"] as PDFArray);
if (array1 == null)
{
throw new ArgumentException("No FontMatrix entry for the Type3 font.");
}
if (6 != array1.Count)
{
throw new ArgumentException("Incorrect FontMatrix entry for the Type3 font. Must have 6 positions.");
}
double[] numArray1 = new double[6];
for (num1 = 0; (num1 < 6); num1 += 1)
{
numeric1 = (array1[num1] as PDFNumeric);
if (numeric1 == null)
{
throw new ArgumentException("Incorrect datatype for the entry of FontMatrix array.");
}
numArray1[num1] = numeric1.DoubleValue;
}
this.mMatrix = new CTM(numArray1);
}
internal static Resource Factory(PDFDirect d)
{
PDFArray array1;
if (< PrivateImplementationDetails >.$$method0x6000404 - 1 == null)
{
Hashtable hashtable1 = new Hashtable(24, 0.5f);
hashtable1.Add("DeviceGray", 0);
Hashtable hashtable2 = new Hashtable(24, 0.5f);
hashtable2.Add("DeviceRGB", 1);
Hashtable hashtable3 = new Hashtable(24, 0.5f);
hashtable3.Add("DeviceCMYK", 2);
Hashtable hashtable4 = new Hashtable(24, 0.5f);
hashtable4.Add("CalGray", 3);
Hashtable hashtable5 = new Hashtable(24, 0.5f);
hashtable5.Add("CalRGB", 4);
Hashtable hashtable6 = new Hashtable(24, 0.5f);
hashtable6.Add("Lab", 5);
Hashtable hashtable7 = new Hashtable(24, 0.5f);
hashtable7.Add("Indexed", 6);
Hashtable hashtable8 = new Hashtable(24, 0.5f);
hashtable8.Add("Separation", 7);
Hashtable hashtable9 = new Hashtable(24, 0.5f);
hashtable9.Add("DeviceN", 8);
Hashtable hashtable10 = new Hashtable(24, 0.5f);
hashtable10.Add("Pattern", 9);
Hashtable hashtable11 = new Hashtable(24, 0.5f);
hashtable11.Add("ICCBased", 10);
public static Resource Factory(PDFDirect direct)
{
if (direct == null)
{
return(null);
}
string text1 = ((direct as PDFDict)["S"] as PDFName).Value;
if (text1 == null)
{
goto Label_0056;
}
text1 = string.IsInterned(text1);
if (text1 != "MCD")
{
if (text1 == "MCS")
{
goto Label_004F;
}
goto Label_0056;
}
return(new MediaClipData(direct));
Label_004F:
return(new MediaClipSection(direct));
Label_0056:
return(null);
}
// Methods
internal ComplexObjectCommonArrayBase(PDFDirect direct, int ObjSize) : base(direct)
{
int num1;
int num2;
this.mIndexSkip = 0;
this.mObjSize = 1;
this.mObjectList = new ArrayList();
this.mArr = null;
this.mInternalArr = Library.CreateArray(0);
this.mArr = (direct as PDFArray);
this.mObjSize = ObjSize;
if (this.mArr == null)
{
return;
}
for (num1 = this.mIndexSkip; (num1 < (this.mArr.Count / this.mObjSize)); num1 += 1)
{
this.mInternalArr[num1] = Library.CreateArray(this.mObjSize);
for (num2 = 0; (num2 < this.mObjSize); num2 += 1)
{
(this.mInternalArr[num1] as PDFArray)[num2] = this.mArr[((num1 * this.mObjSize) + num2)];
}
}
}
// Methods
internal FunctionType0(PDFDirect d) : base(d)
{
this.mEncode = null;
this.mDecode = null;
this.mSize = null;
this.mData = null;
}
internal static Resource Factory(PDFDirect d)
{
if (d.PDFType != PDFObjectType.tPDFDict)
{
goto Label_0061;
}
PDFDict dict1 = ((PDFDict)d);
int num1 = ((PDFInteger)dict1["FunctionType"]).Int32Value;
int num3 = num1;
switch (num3)
{
case 2:
{
goto Label_003C;
}
case 3:
{
goto Label_0043;
}
}
goto Label_004A;
Label_003C:
return(new FunctionType2(d));
Label_0043:
return(new FunctionType3(d));
Label_004A:
throw new PDFSyntaxException(d, string.Format("Unknown function type: {0}", num1));
Label_0061:
if (d.PDFType != PDFObjectType.tPDFStream)
{
goto Label_00C0;
}
PDFStream stream1 = ((PDFStream)d);
int num2 = ((PDFInteger)stream1.Dict["FunctionType"]).Int32Value;
num3 = num2;
if (num3 != 0)
{
if (num3 == 4)
{
goto Label_00A2;
}
goto Label_00A9;
}
return(new FunctionType0(d));
Label_00A2:
return(new FunctionType4(d));
Label_00A9:
throw new PDFSyntaxException(d, string.Format("Unknown function type: {0}", num2));
Label_00C0:
throw new PDFSyntaxException(d, "Invalid Function");
}
internal void DecryptObject(PDFDirect direct, int id, int gene)
{
PDFObject obj2;
IEnumerator enumerator1;
IDisposable disposable1;
PDFObjectType type1 = direct.PDFType;
switch (type1)
{
case PDFObjectType.tPDFString:
{
((CorePDFString)direct).mValue = Utils.BytesToString(this.Encryption.DecryptString(((CorePDFString)direct), id, gene));
return;
}
case PDFObjectType.tPDFDict:
{
goto Label_008F;
}
case PDFObjectType.tPDFArray:
{
foreach (PDFObject obj1 in ((PDFArray)direct))
{
if (obj1.IsIndirect)
{
continue;
}
this.DecryptObject(obj1.Direct, id, gene);
}
return;
}
}
return;
Label_008F:
enumerator1 = ((PDFDict)direct).Values.GetEnumerator();
try
{
while (enumerator1.MoveNext())
{
obj2 = ((PDFObject)enumerator1.Current);
if (obj2.IsIndirect)
{
continue;
}
this.DecryptObject(obj2.Direct, id, gene);
}
}
finally
{
disposable1 = (enumerator1 as IDisposable);
if (disposable1 != null)
{
disposable1.Dispose();
}
}
}
// Methods
internal XObjectImage(PDFDirect d) : base(d)
{
this.mCS = null;
this.mMaskColorRange = null;
this.mMask = null;
this.mSMask = null;
this.mDecode = null;
this.mAlternates = null;
}
internal static Resource Factory(PDFDirect d)
{
int num1;
Resource resource1;
int num2;
try
{
num1 = ((PDFInteger)((d.PDFType == PDFObjectType.tPDFDict) ? ((PDFDict)d) : ((PDFStream)d).Dict)["ShadingType"]).Int32Value;
num2 = num1;
switch (num2)
{
case 1:
{
return(new ShadingType1(d));
}
case 2:
{
return(new ShadingType2(d));
}
case 3:
{
return(new ShadingType3(d));
}
case 4:
{
return(new ShadingType4(d));
}
case 5:
{
return(new ShadingType5(d));
}
case 6:
{
return(new ShadingType6(d));
}
case 7:
{
return(new ShadingType7(d));
}
}
throw new PDFSyntaxException(d, "Invalid shading");
}
catch (InvalidCastException)
{
throw new PDFSyntaxException(d, "Invalid shading");
}
return(resource1);
}
internal static Resource Factory(PDFDirect d)
{
PDFDict dict1;
string text1;
Resource resource1;
try
{
dict1 = (d as PDFDict);
if (dict1 == null)
{
throw new ArgumentException("Not a font DICTIONARY");
}
if (((PDFName)dict1["Type"]).Value != "Font")
{
throw new ArgumentException("Not a FONT dictionary");
}
text1 = ((PDFName)dict1["Subtype"]).Value;
if (text1 == "Type0")
{
return(new FontType0(d));
}
if (text1 == "Type1")
{
return(new FontType1(d));
}
if (text1 == "Type3")
{
return(new FontType3(d));
}
if (text1 == "TrueType")
{
return(new FontTrueType(d));
}
if (text1 == "MMType1")
{
return(new FontType1(d));
}
if (text1 == "CIDFontType0")
{
return(new FontType0(d));
}
if (text1 == "CIDFontType2")
{
return(new FontType0(d));
}
throw new PDFException("Unknown font SUBTYPE");
}
catch (NullReferenceException)
{
throw new ArgumentException("INVALID font dictionary");
}
return(resource1);
}
internal override object ComplexObjectFactory(PDFDirect dir)
{
PDFIndirect indirect1 = dir.Indirect;
foreach (Page page1 in dir.Doc.Pages)
{
if (page1.Dict.Indirect != indirect1)
{
continue;
}
return(page1);
}
return(null);
}
internal static Resource Factory(PDFDirect d)
{
if (< PrivateImplementationDetails >.$$method0x6000121 - 1 == null)
{
Hashtable hashtable1 = new Hashtable(48, 0.5f);
hashtable1.Add("Text", 0);
Hashtable hashtable2 = new Hashtable(48, 0.5f);
hashtable2.Add("FreeText", 1);
Hashtable hashtable3 = new Hashtable(48, 0.5f);
hashtable3.Add("Line", 2);
Hashtable hashtable4 = new Hashtable(48, 0.5f);
hashtable4.Add("Square", 3);
Hashtable hashtable5 = new Hashtable(48, 0.5f);
hashtable5.Add("Circle", 4);
Hashtable hashtable6 = new Hashtable(48, 0.5f);
hashtable6.Add("Polygon", 5);
Hashtable hashtable7 = new Hashtable(48, 0.5f);
hashtable7.Add("Polyline", 6);
Hashtable hashtable8 = new Hashtable(48, 0.5f);
hashtable8.Add("Highlight", 7);
Hashtable hashtable9 = new Hashtable(48, 0.5f);
hashtable9.Add("Underline", 8);
Hashtable hashtable10 = new Hashtable(48, 0.5f);
hashtable10.Add("Squiggly", 9);
Hashtable hashtable11 = new Hashtable(48, 0.5f);
hashtable11.Add("StrikeOut", 10);
Hashtable hashtable12 = new Hashtable(48, 0.5f);
hashtable12.Add("Stamp", 11);
Hashtable hashtable13 = new Hashtable(48, 0.5f);
hashtable13.Add("Caret", 12);
Hashtable hashtable14 = new Hashtable(48, 0.5f);
hashtable14.Add("Ink", 13);
Hashtable hashtable15 = new Hashtable(48, 0.5f);
hashtable15.Add("FileAttachment", 14);
Hashtable hashtable16 = new Hashtable(48, 0.5f);
hashtable16.Add("Sound", 15);
Hashtable hashtable17 = new Hashtable(48, 0.5f);
hashtable17.Add("Link", 16);
Hashtable hashtable18 = new Hashtable(48, 0.5f);
hashtable18.Add("Popup", 17);
Hashtable hashtable19 = new Hashtable(48, 0.5f);
hashtable19.Add("Movie", 18);
Hashtable hashtable20 = new Hashtable(48, 0.5f);
hashtable20.Add("Widget", 19);
Hashtable hashtable21 = new Hashtable(48, 0.5f);
hashtable21.Add("Screen", 20);
Hashtable hashtable22 = new Hashtable(48, 0.5f);
hashtable22.Add("PrinterMark", 21);
Hashtable hashtable23 = new Hashtable(48, 0.5f);
hashtable23.Add("TrapNet", 22);
public Halftone this[string colorant]
{
get
{
PDFDirect direct1 = (this.Dict[colorant] as PDFDirect);
if (direct1 == null)
{
return(null);
}
return(Resources.Get(direct1, typeof(Halftone)) as Halftone);
}
set
{
this.Dict[colorant] = value.Dict;
}
}
internal static Resource Factory(PDFDirect direct)
{
if ((direct is PDFString))
{
return(new LinkDestinationNamed(direct));
}
if ((direct is PDFArray))
{
return(new LinkDestinationExplicit(direct));
}
if ((direct is PDFName))
{
return(null);
}
return(null);
}
internal ExtGState(PDFDirect d) : base(d)
{
this.mDashPattern = null;
this.mFont = null;
this.mBG = null;
this.mBG2 = null;
this.mUCR = null;
this.mUCR2 = null;
this.mBlendMode = null;
try
{
this.mDict = ((PDFDict)d);
}
catch (InvalidCastException)
{
throw new ArgumentException("Constructor parameter should be a DICTIONARY");
}
}
public Resource Add(Resource res)
{
Document document1 = this.mDoc;
if (res.Direct.Doc == this.mDoc)
{
return(res);
}
PDFObject obj1 = document1.CloneObject((res.Direct.IsIndirect ? res.Direct.Indirect : res.Direct));
if (obj1.IsIndirect)
{
return(this[obj1, res.GetType()]);
}
PDFDirect direct1 = ((PDFDirect)obj1);
document1.Indirects.New().Direct = direct1;
return(this[direct1, res.GetType()]);
}
internal static Resource Factory(PDFDirect direct)
{
PDFDict dict1 = (direct as PDFDict);
if (dict1 == null)
{
return(null);
}
PDFName name1 = (dict1["Type"] as PDFName);
if (name1 == null)
{
return(null);
}
if (name1.Value != "Page")
{
return(null);
}
return(new Page(dict1));
}
protected Font(PDFDirect d) : base(d)
{
PDFDict dict2;
PDFArray array1;
PDFArray array2;
this.isWidthRead = false;
this.isEncodingRead = false;
this.mMatrix = new CTM(0.001f, 0f, 0f, 0.001f, 0f, 0f);
this.mBBox = new Rect(-200f, -250f, 1050f, 1100f);
PDFDict dict1 = null;
if (this.SubType == EFontType.Type0)
{
array1 = (this.Dict["DescendantFonts"] as PDFArray);
if (array1 != null)
{
dict2 = (array1[0] as PDFDict);
if (dict2 != null)
{
dict1 = (dict2["FontDescriptor"] as PDFDict);
}
}
}
else
{
dict1 = (this.Dict["FontDescriptor"] as PDFDict);
}
if (dict1 != null)
{
array2 = (dict1["FontBBox"] as PDFArray);
if (array2 == null)
{
throw new ArgumentException("Bad Font BBox");
}
this.mBBox = new PDFRect(array2);
}
this.mWidths = new Hashtable();
this.mEncoding = new string[256];
}
