public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var dict = value as IDictionary<PropertyName, IProperty>;
if (dict == null) return;
var settings = serializer.GetConnectionSettings();
var props = new Properties();
foreach (var kv in dict)
{
var v = kv.Value as IPropertyWithClrOrigin;
if (v?.ClrOrigin == null)
{
props.Add(kv.Key, kv.Value);
continue;
}
//We do not have to take .Name into account from serializer PropertyName (kv.Key) already handles this
var serializerMapping = settings.Serializer?.CreatePropertyMapping(v.ClrOrigin);
if (serializerMapping == null || !serializerMapping.Ignore)
props.Add(kv.Key, kv.Value);
}
_dictionaryConverter.WriteJson(writer, props, serializer);
}
public StructureObjectArray(PsdReader reader)
{
int version = reader.ReadInt32();
this.Add("Name", reader.ReadString());
this.Add("ClassID", reader.ReadKey());
int count = reader.ReadInt32();
List<Properties> items = new List<Properties>();
for (int i = 0; i < count; i++)
{
Properties props = new Properties();
props.Add("Type1", reader.ReadKey());
props.Add("EnumName", reader.ReadType());
props.Add("Type2", PsdUtility.ToUnitType(reader.ReadType()));
int d4 = reader.ReadInt32();
props.Add("Values", reader.ReadDoubles(d4));
items.Add(props);
}
this.Add("items", items.ToArray());
}
public IProperties GetProperties(ConcurrentDictionary<Type, int> seenTypes = null, int maxRecursion = 0)
{
var properties = new Properties();
int seen;
if (seenTypes != null && seenTypes.TryGetValue(_type, out seen) && seen > maxRecursion)
return properties;
foreach (var propertyInfo in _type.GetProperties())
{
var attribute = ElasticsearchPropertyAttribute.From(propertyInfo);
if (attribute != null && attribute.Ignore)
continue;
var property = GetProperty(propertyInfo, attribute);
properties.Add(propertyInfo, property);
}
return properties;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var r = new Properties();
JObject o = JObject.Load(reader);
foreach (var p in o.Properties())
{
var name = p.Name;
var po = p.First as JObject;
if (po == null)
continue;
var mapping = _elasticTypeConverter.ReadJson(po.CreateReader(), objectType, existingValue, serializer)
as IProperty;
if (mapping == null)
continue;
mapping.Name = name;
r.Add(name, mapping);
}
return r;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jToken = JToken.ReadFrom(reader);
if (jToken.Type == JTokenType.Array)
{
return new Properties();
}
if (jToken.Type == JTokenType.Object)
{
var properties = new Properties();
foreach (var property in ((JObject)jToken).Properties())
{
if(property.Name == "headers")
{
if (property.Value.Type == JTokenType.Object)
{
var headers = (JObject) property.Value;
foreach (var header in headers.Properties())
{
properties.headers.Add(header.Name, header.Value.ToString());
}
}
}
else
{
properties.Add(property.Name, property.Value.ToString());
}
}
return properties;
}
throw new JsonException(
string.Format("Expected array or object for properties, but was {0}", jToken.Type), null);
}
private void initializeRegistrationProperties()
{
Properties.Add("username", "");
Properties.Add("duplicated_password", "");
}
public LengthException(string input, int inputLength) : base(typeof(LengthException))
{
Properties.Add(nameof(input), input);
Properties.Add(nameof(inputLength), inputLength);
}
static void ReadTileset(XmlNode node, ref Map map, string base_path)
{
TileSet r = new TileSet();
r.FirstGid = node.ReadInt("firstgid");
r.Source = node.ReadTag("source");
r.Name = node.ReadTag("name");
r.TileWidth = node.ReadInt("tilewidth");
r.TileHeight = node.ReadInt("tileheight");
r.Spacing = node.ReadInt("spacing");
r.Margin = node.ReadInt("margin");
Console.Out.WriteLine (r.Source);
if (r.Source != "") {
String filename = Path.Combine (base_path, r.Source);
Console.Out.WriteLine (r.Source);
try {
XmlDocument extTileset = new XmlDocument ();
extTileset.Load (File.OpenRead (filename));
foreach (XmlNode extNode in extTileset.ChildNodes) {
if (extNode.Name == "tileset")
node = extNode;
}
r.Name = node.ReadTag("name");
r.TileWidth = node.ReadInt("tilewidth");
r.TileHeight = node.ReadInt("tileheight");
r.Spacing = node.ReadInt("spacing");
r.Margin = node.ReadInt("margin");
FileInfo fi = new FileInfo (filename);
base_path = fi.DirectoryName;
} catch (Exception e) {
Console.Out.WriteLine (e.Message);
return;
}
}
if (node.HasChildNodes)
{
foreach (XmlNode child in node.ChildNodes)
{
if (child.Name == "image") {
string c = child.ReadTag ("trans", "FFFFFF");
if (c.Length == 6 && !c.StartsWith ("#")) {
c = "#" + c;
}
Color t = ColorTranslator.FromHtml (c);
if (child.Attributes ["trans"] != null) {
r.Images.Add (new Image () {
Source = child.ReadTag ("source"),
TransColor = t,
UseTransColor = true
});
} else {
r.Images.Add (new Image () {
Source = child.ReadTag ("source"),
TransColor = t,
UseTransColor = false
});
}
} else if (child.Name == "tile") {
int id = child.ReadInt ("id");
Properties tileprops = new Properties();
XmlNode data = child.FirstChild; // Should be a properties tag.
foreach (XmlNode property in data.ChildNodes) {
tileprops.Add (property.ReadTag ("name"), property.ReadTag ("value"));
}
r.TileProperties.Add (id, tileprops);
}
}
}
//r.ReadBitmaps(base_path);
map.TileSets.Add(r);
}
public GeneratedUClass(Type reflectedClass)
{
reflectedClassType = reflectedClass;
Name = reflectedClass.Name;
Type = reflectedClass.GetCustomAttribute <GenerateApiAttribute>().ClassType;
if (Type == UClassType.Request)
{
foreach (var requesDataField in reflectedClass.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)
.Where(property => property.GetCustomAttributes <ApiRequestDataAttribute>(true).Any()))
{
RequestArguments.Add(new UProperty(requesDataField, true));
}
if (reflectedClass.GetCustomAttributes <RequireServerAuthAttribute>(true).Any())
{
RequestArguments.Add(new UProperty()
{
Name = "ServerAuthKey", Type = PropertyType.String, IsArgument = true
});
if (RequestArguments.Count >= 2)
{
RequestArguments.Swap(0, RequestArguments.Count - 1);
}
}
else if (reflectedClass.GetCustomAttributes <RequireAuthAttribute>(true).Any())
{
if (!RequestArguments.Exists(a => a.Name.Equals("PlayerId", StringComparison.OrdinalIgnoreCase)))
{
RequestArguments.Add(new UProperty()
{
Name = "PlayerId", Type = PropertyType.String, IsArgument = true
});
if (RequestArguments.Count >= 2)
{
RequestArguments.Swap(0, RequestArguments.Count - 1);
}
}
RequestArguments.Add(new UProperty()
{
Name = "SessionToken", Type = PropertyType.String, IsArgument = true
});
if (RequestArguments.Count >= 3)
{
RequestArguments.Swap(1, RequestArguments.Count - 1);
}
}
foreach (var responseDataField in reflectedClass.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)
.Where(property => property.GetCustomAttributes <ApiResponseDataAttribute>(true).Any()))
{
Properties.Add(new UProperty(responseDataField));
}
}
else if (Type == UClassType.Enum)
{
foreach (var enumValue in reflectedClass.GetEnumNames())
{
EnumValues.Add(enumValue);
}
}
else
{
foreach (var reflectedProperty in reflectedClass.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)
.Where(property => !property.GetCustomAttributes <IgnorePropertyAttribute>(true).Any() && property.CanWrite))
{
Properties.Add(new UProperty(reflectedProperty));
}
}
}
public void AddProperty(string name)
{
Properties.Add(name);
}
/// <summary>
/// Sets a value for an attribute.
/// </summary>
/// <param name="name">the iText tagname</param>
/// <param name="value">the default value for this tag</param>
public void AddValue(string name, string value)
{
AttributeValues.Add(name, value);
}
public void Add(string propName, RavenJToken token)
{
Properties.Add(propName, token);
}
/// <summary>
/// To set the property based on Property name and value.
/// </summary>
/// <param name="name">Name (String) of the record property.</param>
/// <param name="value">value (Object) of the record property.</param>
public void SetProperty(string name, object value)
{
Properties.Add(name, value);
}
private void GetRelated()
{
// Clear related
Regions.Clear();
Properties.Clear();
AttachedContent.Clear();
// Get group parents
DisableGroups = SysGroup.GetParents(Page.GroupId);
DisableGroups.Reverse();
// Get template & permalink
Template = PageTemplate.GetSingle("pagetemplate_id = @0", Page.TemplateId);
Permalink = Permalink.GetSingle(Page.PermalinkId);
if (Permalink == null)
{
// Get the site tree
using (var db = new DataContext()) {
var sitetree = db.SiteTrees.Where(s => s.Id == Page.SiteTreeId).Single();
Permalink = new Permalink()
{
Id = Guid.NewGuid(), Type = Permalink.PermalinkType.PAGE, NamespaceId = sitetree.NamespaceId
};
Page.PermalinkId = Permalink.Id;
}
}
// Get placement ref title
if (!IsSite)
{
if (Page.ParentId != Guid.Empty || Page.Seqno > 1)
{
Page refpage = null;
if (Page.Seqno > 1)
{
if (Page.ParentId != Guid.Empty)
{
refpage = Page.GetSingle("page_parent_id = @0 AND page_seqno = @1", Page.ParentId, Page.Seqno - 1);
}
else
{
refpage = Page.GetSingle("page_parent_id IS NULL AND page_seqno = @0 AND page_sitetree_id = @1", Page.Seqno - 1, Page.SiteTreeId); //ÖS 2015-03-18 added siteid to the query
}
}
else
{
refpage = Page.GetSingle(Page.ParentId, true);
}
PlaceRef = refpage.Title;
}
}
if (Template != null)
{
// Only load regions & properties if this is an original
if (Page.OriginalId == Guid.Empty)
{
// Get regions
var regions = RegionTemplate.Get("regiontemplate_template_id = @0", Template.Id, new Params()
{
OrderBy = "regiontemplate_seqno"
});
foreach (var rt in regions)
{
var reg = Region.GetSingle("region_regiontemplate_id = @0 AND region_page_id = @1 and region_draft = @2",
rt.Id, Page.Id, Page.IsDraft);
if (reg != null)
{
Regions.Add(reg);
}
else
{
Regions.Add(new Region()
{
InternalId = rt.InternalId,
Name = rt.Name,
Type = rt.Type,
PageId = Page.Id,
RegiontemplateId = rt.Id,
IsDraft = Page.IsDraft,
IsPageDraft = Page.IsDraft
});
}
}
// Get Properties
foreach (string name in Template.Properties)
{
Property prp = Property.GetSingle("property_name = @0 AND property_parent_id = @1 AND property_draft = @2",
name, Page.Id, Page.IsDraft);
if (prp != null)
{
Properties.Add(prp);
}
else
{
Properties.Add(new Property()
{
Name = name, ParentId = Page.Id, IsDraft = Page.IsDraft
});
}
}
}
}
else
{
throw new ArgumentException("Could not find page template for page {" + Page.Id.ToString() + "}");
}
// Only load attachments if this is an original
if (Page.OriginalId == Guid.Empty)
{
// Get attached content
if (Page.Attachments.Count > 0)
{
// Content meta data is actually memcached, so this won't result in multiple queries
Page.Attachments.ForEach(a => {
Models.Content c = Models.Content.GetSingle(a, true);
if (c != null)
{
AttachedContent.Add(c);
}
});
}
}
// Get page position
Parents = BuildParentPages(Sitemap.GetStructure(Page.SiteTreeInternalId, false), Page);
Parents.Insert(0, new PagePlacement()
{
Level = 1, IsSelected = Page.ParentId == Guid.Empty
});
Siblings = BuildSiblingPages(Page.Id, Page.ParentId, Page.Seqno, Page.ParentId, Page.SiteTreeInternalId);
// Only load extensions if this is an original
if (Page.OriginalId == Guid.Empty)
{
// Get extensions
Extensions = Page.GetExtensions(true);
}
// Initialize regions
foreach (var reg in Regions)
{
reg.Body.InitManager(this);
}
// Get whether comments should be enabled
EnableComments = Areas.Manager.Models.CommentSettingsModel.Get().EnablePages;
if (!Page.IsNew && EnableComments)
{
using (var db = new DataContext()) {
Comments = db.Comments.
Include("CreatedBy").
Where(c => c.ParentId == Page.Id && c.ParentIsDraft == false).
OrderByDescending(c => c.Created).ToList();
}
}
// Get the site if this is a site page
if (Permalink.Type == Models.Permalink.PermalinkType.SITE)
{
using (var db = new DataContext()) {
SiteTree = db.SiteTrees.Where(s => s.Id == Page.SiteTreeId).Single();
}
}
// Check if the page can be published
if (Page.OriginalId != Guid.Empty)
{
CanPublish = Page.GetScalar("SELECT count(*) FROM page WHERE page_id=@0 AND page_draft=0", Page.OriginalId) > 0;
}
}
public virtual void SetMarkupAttribute(String key, String value)
{
markupAttributes.Add(key, value);
}
public virtual void TryInheritFrom(IEntity parent)
{
if (parent is IHasProperties hasProperties)
{
//Properties inheritance
foreach (var parentProperty in hasProperties.Properties ?? Array.Empty <Property>())
{
if (Properties == null)
{
Properties = new List <Property>();
}
var existProperty = Properties.FirstOrDefault(x => x.IsSame(parentProperty, PropertyType.Product, PropertyType.Variation));
if (existProperty == null)
{
existProperty = AbstractTypeFactory <Property> .TryCreateInstance();
Properties.Add(existProperty);
}
existProperty.TryInheritFrom(parentProperty);
existProperty.IsReadOnly = existProperty.Type != PropertyType.Variation && existProperty.Type != PropertyType.Product;
}
//Restore sorting order after changes
if (Properties != null)
{
Properties = Properties.OrderBy(x => x.Name).ToList();
}
}
if (parent is IHasTaxType hasTaxType)
{
//TODO: prevent saving the inherited simple values
//TaxType inheritance
if (TaxType == null)
{
TaxType = hasTaxType.TaxType;
}
}
if (parent is CatalogProduct parentProduct)
{
var isVariation = GetType().IsAssignableFrom(typeof(Variation));
//Inherit images from parent product (if its not set)
if (Images.IsNullOrEmpty() && !parentProduct.Images.IsNullOrEmpty())
{
Images = new List <Image>();
foreach (var parentImage in parentProduct.Images)
{
var image = AbstractTypeFactory <Image> .TryCreateInstance();
image.TryInheritFrom(parentImage);
Images.Add(image);
}
}
//Inherit assets from parent product (if its not set)
if (Assets.IsNullOrEmpty() && !parentProduct.Assets.IsNullOrEmpty())
{
Assets = new List <Asset>();
foreach (var parentAsset in parentProduct.Assets)
{
var asset = AbstractTypeFactory <Asset> .TryCreateInstance();
asset.TryInheritFrom(parentAsset);
Assets.Add(asset);
}
}
//inherit editorial reviews from main product and do not inherit if variation loaded within product
if (!isVariation && Reviews.IsNullOrEmpty() && parentProduct.Reviews != null)
{
Reviews = new List <EditorialReview>();
foreach (var parentReview in parentProduct.Reviews)
{
var review = AbstractTypeFactory <EditorialReview> .TryCreateInstance();
review.TryInheritFrom(parentReview);
Reviews.Add(review);
}
}
//inherit not overridden property values from main product
foreach (var parentProductProperty in parentProduct.Properties ?? Array.Empty <Property>())
{
var existProperty = Properties.FirstOrDefault(x => x.IsSame(parentProductProperty, PropertyType.Product, PropertyType.Variation));
if (existProperty == null)
{
existProperty = AbstractTypeFactory <Property> .TryCreateInstance();
Properties.Add(existProperty);
}
existProperty.TryInheritFrom(parentProductProperty);
existProperty.IsReadOnly = existProperty.Type != PropertyType.Variation && existProperty.Type != PropertyType.Product;
//Inherit only parent Product properties values if own values aren't set
if (parentProductProperty.Type == PropertyType.Product)
{
if (existProperty.Values.IsNullOrEmpty() && !parentProductProperty.Values.IsNullOrEmpty())
{
existProperty.Values = new List <PropertyValue>();
foreach (var parentPropValue in parentProductProperty.Values)
{
var propValue = AbstractTypeFactory <PropertyValue> .TryCreateInstance();
propValue.TryInheritFrom(parentPropValue);
existProperty.Values.Add(propValue);
}
}
}
}
//TODO: prevent saving the inherited simple values
Width = parentProduct.Width ?? Width;
Height = parentProduct.Height ?? Height;
Length = parentProduct.Length ?? Length;
MeasureUnit = parentProduct.MeasureUnit ?? MeasureUnit;
Weight = parentProduct.Weight ?? Weight;
WeightUnit = parentProduct.WeightUnit ?? WeightUnit;
PackageType = parentProduct.PackageType ?? PackageType;
if (!Variations.IsNullOrEmpty())
{
foreach (var variation in Variations)
{
variation.TryInheritFrom(this);
}
}
}
}
/// <summary>
/// Register the property we want to provider a design time version of.
/// </summary>
public TabControlDesignModeValueProvider()
{
Properties.Add(MyPlatformTypes.TabControl.SelectedIndexProperty);
}
/// <summary>
/// See <see cref="M:iTextSharp.text.IMarkupAttributes.setMarkupAttribute(System.String,System.String)"/>
/// </summary>
/// <param name="name">attribute name</param>
/// <param name="value">attribute value</param>
public void setMarkupAttribute(string name, string value)
{
markupAttributes = (markupAttributes == null) ? new Properties() : markupAttributes;
markupAttributes.Add(name, value);
}
public ClientConfiguration(ClientConfigurationList parentList)
{
_parentList = parentList;
// Client properties
PrivateKeyProperty.TargetTypes.Add(GetType());
DnsProperty.TargetTypes.Add(GetType());
AddressProperty.TargetTypes.Add(GetType());
// Server properties
PresharedKeyProperty.TargetTypes.Add(typeof(ServerConfiguration));
PublicKeyProperty.TargetTypes.Add(typeof(ServerConfiguration));
ServerPersistentKeepaliveProperty.TargetTypes.Add(typeof(ServerConfiguration));
var serverConfiguration = new ServerConfiguration().Load <ServerConfiguration>(Configuration.LoadFromFile(ServerConfigurationPrerequisite.ServerDataPath));
string serverIp = serverConfiguration.AddressProperty.Value;
// Add support for generating client IP
AddressProperty.Action = new ConfigurationPropertyAction(this)
{
Name = nameof(Resources.GenerateFromServerAction),
Description = string.Format(Resources.GenerateClientAddressActionDescription, serverIp),
DependentProperty = serverConfiguration.AddressProperty,
DependencySatisfiedFunc = prop => string.IsNullOrEmpty(prop.Validation?.Validate?.Invoke(prop)),
Action = (conf, prop) =>
{
IPNetwork serverNetwork = IPNetwork.Parse(serverConfiguration.AddressProperty.Value);
var possibleAddresses = serverNetwork.ListIPAddress().Skip(2).SkipLast(1).ToList(); // Skip reserved .0 and .1 and .255.
// If the current address is already in range, we're done
if (possibleAddresses.Select(a => a.ToString()).Contains(prop.Value))
{
return;
}
WaitCursor.SetOverrideCursor(Cursors.Wait);
var existingAddresses = parentList.List.Select(c => c.AddressProperty.Value);
// Find the first address that isn't used by another client
prop.Value = possibleAddresses.FirstOrDefault(a => existingAddresses.Contains(a.ToString()) == false)?.ToString();
WaitCursor.SetOverrideCursor(null);
}
};
// Do custom validation on the Address (we want a specific IP or a CIDR with /32)
AddressProperty.Validation = new ConfigurationPropertyValidation
{
Validate = obj =>
{
string result = default;
// First, try parsing with IPNetwork to see if it's in CIDR format
if (IPNetwork.TryParse(obj.Value, out var network))
{
// At this point, we know it's a valid network. Let's see how many addresses are in range
if (network.Usable > 1)
{
// It's CIDR, but it defines more than one address.
// However, IPNetwork has a quirk that parses single addresses (without mask) as a range.
// So now let's see if it's a single address
if (IPAddress.TryParse(obj.Value, out _) == false)
{
// If we get here, it passed CIDR parsing, but it defined more than one address (i.e., had a mask). It's bad!
result = Resources.ClientAddressValidationError;
}
// Else, it's a single address as parsed by IPAddress, so we're good!
}
// Else
// It's in CIDR notation and only defines a single address (/32) so we're good!
}
else
{
// Not even IPNetwork could parse it, so it's really bad!
result = Resources.ClientAddressValidationError;
}
return(result);
}
};
// The client generates the PSK
PresharedKeyProperty.Action = new ConfigurationPropertyAction(this)
{
Name = $"{nameof(PresharedKeyProperty)}{nameof(ConfigurationProperty.Action)}",
Action = (conf, prop) =>
{
WaitCursor.SetOverrideCursor(Cursors.Wait);
prop.Value = new WireGuardExe().ExecuteCommand(new GeneratePresharedKeyCommand());
WaitCursor.SetOverrideCursor(null);
}
};
// Allowed IPs is special, because for the server, it's the same as the Address property for the client
var allowedIpsProperty = new ConfigurationProperty(this)
{
PersistentPropertyName = "AllowedIPs",
Value = AddressProperty.Value,
IsHidden = true
};
allowedIpsProperty.TargetTypes.Add(typeof(ServerConfiguration));
AddressProperty.PropertyChanged += (_, args) =>
{
if (args.PropertyName == nameof(AddressProperty.Value))
{
allowedIpsProperty.Value = AddressProperty.Value;
}
};
Properties.Add(allowedIpsProperty);
// Adjust index of properties and resort
AddressProperty.Index = 1;
DnsProperty.Index = 2;
SortProperties();
Properties.ForEach(p => p.PropertyChanged += (_, args) =>
{
if (args.PropertyName == nameof(p.Value))
{
GenerateQrCodeAction.RaisePropertyChanged(nameof(GenerateQrCodeAction.DependencySatisfied));
ExportConfigurationFileAction.RaisePropertyChanged(nameof(ExportConfigurationFileAction.DependencySatisfied));
}
});
}
/// <summary>
/// Replaces the contents of the APP1 section with the Exif properties.
/// </summary>
private bool WriteExifApp1(bool preserveMakerNote)
{
// Zero out IFD field offsets. We will fill those as we write the IFD sections
exifIFDFieldOffset = 0;
gpsIFDFieldOffset = 0;
interopIFDFieldOffset = 0;
firstIFDFieldOffset = 0;
// We also do not know the location of the embedded thumbnail yet
thumbOffsetLocation = 0;
thumbOffsetValue = 0;
thumbSizeLocation = 0;
thumbSizeValue = 0;
// Write thumbnail tags if they are missing, remove otherwise
if (Thumbnail == null)
{
Properties.Remove(ExifTag.ThumbnailJPEGInterchangeFormat);
Properties.Remove(ExifTag.ThumbnailJPEGInterchangeFormatLength);
}
else
{
if (!Properties.ContainsKey(ExifTag.ThumbnailJPEGInterchangeFormat))
{
Properties.Add(new ExifUInt(ExifTag.ThumbnailJPEGInterchangeFormat, 0));
}
if (!Properties.ContainsKey(ExifTag.ThumbnailJPEGInterchangeFormatLength))
{
Properties.Add(new ExifUInt(ExifTag.ThumbnailJPEGInterchangeFormatLength, 0));
}
}
// Which IFD sections do we have?
Dictionary <ExifTag, ExifProperty> ifdzeroth = new Dictionary <ExifTag, ExifProperty>();
Dictionary <ExifTag, ExifProperty> ifdexif = new Dictionary <ExifTag, ExifProperty>();
Dictionary <ExifTag, ExifProperty> ifdgps = new Dictionary <ExifTag, ExifProperty>();
Dictionary <ExifTag, ExifProperty> ifdinterop = new Dictionary <ExifTag, ExifProperty>();
Dictionary <ExifTag, ExifProperty> ifdfirst = new Dictionary <ExifTag, ExifProperty>();
foreach (ExifProperty prop in Properties)
{
switch (prop.IFD)
{
case IFD.Zeroth:
ifdzeroth.Add(prop.Tag, prop);
break;
case IFD.EXIF:
ifdexif.Add(prop.Tag, prop);
break;
case IFD.GPS:
ifdgps.Add(prop.Tag, prop);
break;
case IFD.Interop:
ifdinterop.Add(prop.Tag, prop);
break;
case IFD.First:
ifdfirst.Add(prop.Tag, prop);
break;
}
}
// Add IFD pointers if they are missing
// We will write the pointer values later on
if (ifdexif.Count != 0 && !ifdzeroth.ContainsKey(ExifTag.EXIFIFDPointer))
{
ifdzeroth.Add(ExifTag.EXIFIFDPointer, new ExifUInt(ExifTag.EXIFIFDPointer, 0));
}
if (ifdgps.Count != 0 && !ifdzeroth.ContainsKey(ExifTag.GPSIFDPointer))
{
ifdzeroth.Add(ExifTag.GPSIFDPointer, new ExifUInt(ExifTag.GPSIFDPointer, 0));
}
if (ifdinterop.Count != 0 && !ifdexif.ContainsKey(ExifTag.InteroperabilityIFDPointer))
{
ifdexif.Add(ExifTag.InteroperabilityIFDPointer, new ExifUInt(ExifTag.InteroperabilityIFDPointer, 0));
}
// Remove IFD pointers if IFD sections are missing
if (ifdexif.Count == 0 && ifdzeroth.ContainsKey(ExifTag.EXIFIFDPointer))
{
ifdzeroth.Remove(ExifTag.EXIFIFDPointer);
}
if (ifdgps.Count == 0 && ifdzeroth.ContainsKey(ExifTag.GPSIFDPointer))
{
ifdzeroth.Remove(ExifTag.GPSIFDPointer);
}
if (ifdinterop.Count == 0 && ifdexif.ContainsKey(ExifTag.InteroperabilityIFDPointer))
{
ifdexif.Remove(ExifTag.InteroperabilityIFDPointer);
}
if (ifdzeroth.Count == 0 && ifdgps.Count == 0 && ifdinterop.Count == 0 && ifdfirst.Count == 0 && Thumbnail == null)
{
// Nothing to write
return(false);
}
// We will need these bitconverter to write byte-ordered data
BitConverterEx bceExif = new BitConverterEx(BitConverterEx.SystemByteOrder, ByteOrder);
// Create a memory stream to write the APP1 section to
MemoryStream ms = new MemoryStream();
// Exif identifer
ms.Write(Encoding.ASCII.GetBytes("Exif\0\0"), 0, 6);
// TIFF header
// Byte order
long tiffoffset = ms.Position;
ms.Write((ByteOrder == BitConverterEx.ByteOrder.LittleEndian ? new byte[] { 0x49, 0x49 } : new byte[] { 0x4D, 0x4D }), 0, 2);
// TIFF ID
ms.Write(bceExif.GetBytes((ushort)42), 0, 2);
// Offset to 0th IFD
ms.Write(bceExif.GetBytes((uint)8), 0, 4);
// Write IFDs
WriteIFD(ms, ifdzeroth, IFD.Zeroth, tiffoffset, preserveMakerNote);
uint exififdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdexif, IFD.EXIF, tiffoffset, preserveMakerNote);
uint gpsifdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdgps, IFD.GPS, tiffoffset, preserveMakerNote);
uint interopifdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdinterop, IFD.Interop, tiffoffset, preserveMakerNote);
uint firstifdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdfirst, IFD.First, tiffoffset, preserveMakerNote);
// Now that we now the location of IFDs we can go back and write IFD offsets
if (exifIFDFieldOffset != 0)
{
ms.Seek(exifIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(exififdrelativeoffset), 0, 4);
}
if (gpsIFDFieldOffset != 0)
{
ms.Seek(gpsIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(gpsifdrelativeoffset), 0, 4);
}
if (interopIFDFieldOffset != 0)
{
ms.Seek(interopIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(interopifdrelativeoffset), 0, 4);
}
if (firstIFDFieldOffset != 0)
{
ms.Seek(firstIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(firstifdrelativeoffset), 0, 4);
}
// We can write thumbnail location now
if (thumbOffsetLocation != 0)
{
ms.Seek(thumbOffsetLocation, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(thumbOffsetValue), 0, 4);
}
if (thumbSizeLocation != 0)
{
ms.Seek(thumbSizeLocation, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(thumbSizeValue), 0, 4);
}
ms.Close();
// Return APP1 header
exifApp1.Header = ms.ToArray();
return(true);
}
public DataProviderElement()
{
Properties.Add(_propTypeName);
Properties.Add(_propName);
Properties.Add(_propDefault);
}
/// <summary>
/// Sets an alias for an attribute.
/// </summary>
/// <param name="name">the iText tagname</param>
/// <param name="alias">the custom tagname</param>
public virtual void AddAlias(string name, string alias)
{
AttributeAliases.Add(alias, name);
}
private void OnAddPropertyExecuted(string obj)
{
Properties.Add(new MenuItemPropertyViewModel(MenuItem.AddDefaultMenuItemProperty(Model)));
}
/// <summary>
/// Load value from <property>...</property> tag. Null returned if value cannot be determined.
/// </summary>
private Object loadValue(XmlNode e, String key, int type)
{
String text = XMLUtils.GetText(e);
switch (type)
{
case PropertySet_Fields.BOOLEAN:
return TextUtils.ParseBoolean(text);
case PropertySet_Fields.INT:
return TextUtils.ParseInt(text);
case PropertySet_Fields.LONG:
return TextUtils.ParseLong(text);
case PropertySet_Fields.DOUBLE:
return TextUtils.ParseDouble(text);
case PropertySet_Fields.STRING:
case PropertySet_Fields.TEXT:
return text;
case PropertySet_Fields.DATE:
try
{
return DateTime.Parse(text, new DateTimeFormatInfo());
}
catch (FormatException )
{
return null; // if the date cannot be parsed, ignore it.
}
//return null;
case PropertySet_Fields.OBJECT:
try
{
return TextUtils.decodeObject(text);
}
catch (Exception )
{
return null; // if Object cannot be decoded, ignore it.
}
case PropertySet_Fields.XML:
try
{
XmlDocument doc=new XmlDocument();
doc.LoadXml(text);
return doc;
}
catch (Exception )
{
return null; // if XML cannot be parsed, ignore it.
}
case PropertySet_Fields.DATA:
try
{
return new Data(TextUtils.DecodeBytes(text));
}
catch (IOException )
{
return null; // if data cannot be decoded, ignore it.
}
//return null;
case PropertySet_Fields.PROPERTIES:
try
{
Properties props = new Properties();
XmlNodeList pElements = e.SelectNodes( "properties/property");
foreach(XmlNode pElement in pElements)
{
props.Add(XMLUtils.GetAttribute(pElement,"key"), XMLUtils.GetElementText(pElement));
}
return props;
}
catch (Exception )
{
return null; // could not get nodes via x-path
}
default:
return null;
}
}
public void AddProperty(string propertyName, object propertyValue)
{
Properties.Add(propertyName, propertyValue);
}
private void ReadProperties(PsdReader reader, Int32 level, Properties props)
{
reader.Skip('\t', level);
Char c = reader.ReadChar();
if (c == ']')
{
return;
}
else if (c == '<')
{
reader.Skip('<');
}
reader.Skip('\n');
//Properties props = new Properties();
while (true)
{
reader.Skip('\t', level);
c = reader.ReadChar();
if (c == '>')
{
reader.Skip('>');
return;
}
else
{
//assert c == 9;
c = reader.ReadChar();
//assert c == '/' : "unknown char: " + c + " on level: " + level;
String name = String.Empty;
while (true)
{
c = reader.ReadChar();
if (c == ' ' || c == 10)
{
break;
}
name += c;
}
if (c == 10)
{
Properties p = new Properties();
this.ReadProperties(reader, level + 1, p);
if (p.Count > 0)
{
props.Add(name, p);
}
reader.Skip('\n');
}
else if (c == ' ')
{
Object value = this.ReadValue(reader, level + 1);
props.Add(name, value);
}
else
{
//assert false;
}
}
}
}
public CustomSection()
{
Properties.Add(IntDefaultCapacity);
}
protected override bool OnDeserializeUnrecognizedAttribute(string name, string value)
{
Properties.Add(new ConfigurationProperty(name, typeof(String)));
this[name] = value;
return(true);
}
private void ReadProperties(PsdReader reader, int level, Properties props)
{
reader.Skip('\t', level);
char c = reader.ReadChar();
if (c == ']')
{
return;
}
else if (c == '<')
{
reader.Skip('<');
}
reader.Skip('\n');
//Properties props = new Properties();
while (true)
{
reader.Skip('\t', level);
c = reader.ReadChar();
if (c == '>')
{
reader.Skip('>');
return;
}
else
{
//assert c == 9;
c = reader.ReadChar();
//assert c == '/' : "unknown char: " + c + " on level: " + level;
string name = string.Empty;
while (true)
{
c = reader.ReadChar();
if (c == ' ' || c == 10)
{
break;
}
name += c;
}
if (c == 10)
{
Properties p = new Properties();
this.ReadProperties(reader, level + 1, p);
if (p.Count > 0)
props.Add(name, p);
reader.Skip('\n');
}
else if (c == ' ')
{
object value = this.ReadValue(reader, level + 1);
props.Add(name, value);
}
else
{
//assert false;
}
}
}
}
public void AddProperty(IdentifierExpression property)
{
Properties.Add(property);
}
/// <summary>
/// Optimized version of [[Put]] when the property is known to be undeclared already
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="writable"></param>
/// <param name="configurable"></param>
/// <param name="enumerable"></param>
public void FastAddProperty(string name, JsValue value, bool writable, bool enumerable, bool configurable)
{
Properties.Add(name, new PropertyDescriptor(value, writable, enumerable, configurable));
}
public SyntheticType(IType baseType)
{
if (!ShouldBeSyntheticType(baseType))
{
throw new ArgumentException("{0} is not a valid type for SyntheticType", baseType.ToString());
}
// gosdk: Ensure the generated name does not collide with existing type names
BaseType = baseType;
IType elementType = getElementType(baseType);
if (elementType is PrimaryType)
{
var type = (elementType as PrimaryType).Type;
if (type == KnownPrimaryType.Boolean)
{
Name += "Bool";
}
else if (type == KnownPrimaryType.ByteArray)
{
Name += "ByteArray";
}
else if (type == KnownPrimaryType.Double)
{
Name += "Float64";
}
else if (type == KnownPrimaryType.Int)
{
Name += "Int32";
}
else if (type == KnownPrimaryType.Long)
{
Name += "Int64";
}
else if (type == KnownPrimaryType.Stream)
{
Name += "ReadCloser";
}
else if (type == KnownPrimaryType.String)
{
Name += "String";
}
else if (type == KnownPrimaryType.TimeSpan)
{
Name += "TimeSpan";
}
else if (type == KnownPrimaryType.Base64Url)
{
Name += "Base64Url";
}
else if (type == KnownPrimaryType.UnixTime)
{
Name += "UnixTime";
}
}
else if (elementType is InterfaceType)
{
Name += "Object";
}
else if (elementType is PackageType)
{
Name += (elementType as PackageType).Member;
}
else if (elementType is EnumType)
{
Name += "String";
}
else
{
Name += elementType.Name;
}
Property p = new Property();
p.SerializedName = "value";
p.Name = "Value";
p.Type = baseType;
Properties.Add(p);
}
/// <summary>
/// Sends the exception's message and stacktrace, plus additional information the
/// program thinks may be relevant. Limitted to MAX_EXCEPTION_REPORTS_PER_RUN
/// </summary>
public static void ReportException(Exception e, Dictionary<string, string> moreProperties)
{
if (!AllowTracking)
return;
_exceptionCount++;
// we had an incident where some problem caused a user to emit hundreds of thousands of exceptions,
// in the background, blowing through our Analytics service limits and getting us kicked off.
if (_exceptionCount > MAX_EXCEPTION_REPORTS_PER_RUN)
{
return;
}
var props = new Properties()
{
{ "Message", e.Message },
{ "Stack Trace", e.StackTrace }
};
if (moreProperties != null)
{
foreach (var key in moreProperties.Keys)
{
props.Add(key, moreProperties[key]);
}
}
TrackWithApplicationProperties("Exception", props);
}
/// <summary>
/// Default constructor to add the property for design time translation.
/// </summary>
public TreeViewItemIsExpandedDesignModeValueProvider()
{
Debug.Assert(!_propertyIdentifier.IsEmpty, "Static constructor should have been called!");
Properties.Add(_propertyIdentifier);
}
/// <summary>
/// Loads all properties from database into objects. If this method is re-called, it will re-query the database.
/// </summary>
/// <remarks>
/// This optimizes sql calls. This will first check if all of the properties have been loaded. If not,
/// then it will query for all property types for the current version from the db. It will then iterate over each
/// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been
/// read, we iterate over the cached property types for this ContentType and create a new property based on
/// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned
/// on all subsequent calls and is also used to return a property with calls to getProperty.
/// </remarks>
private void InitializeProperties()
{
m_LoadedProperties = new Properties();
if (ContentBase != null)
{
//NOTE: we will not load any properties where HasIdentity = false - this is because if properties are
// added to the property collection that aren't persisted we'll get ysods
m_LoadedProperties.AddRange(ContentBase.Properties.Where(x => x.HasIdentity).Select(x => new Property(x)));
return;
}
if (this.ContentType == null)
return;
//Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int.
//This will still be an empty list since the props list is empty.
var propData = m_LoadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList();
string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId";
using (IRecordsReader dr = SqlHelper.ExecuteReader(sql,
SqlHelper.CreateParameter("@versionId", Version)))
{
while (dr.Read())
{
//add the item to our list
propData.Add(new { Id = dr.Get<int>("id"), PropertyTypeId = dr.Get<int>("propertyTypeId") });
}
}
foreach (PropertyType pt in this.ContentType.PropertyTypes)
{
if (pt == null)
continue;
//get the propertyId
var property = propData.LastOrDefault(x => x.PropertyTypeId == pt.Id);
if (property == null)
{
continue;
//var prop = Property.MakeNew(pt, this, Version);
//property = new {Id = prop.Id, PropertyTypeId = pt.Id};
}
var propertyId = property.Id;
Property p = null;
try
{
p = new Property(propertyId, pt);
}
catch
{
continue; //this remains from old code... not sure why we would do this?
}
m_LoadedProperties.Add(p);
}
}
public TestAmendment()
{
#region Methods
// Modify Multiply to also set the Result property to the resulting value
Methods
.Named("Multiply")
.WithParams <int, int>()
.Before((T instance, ref int x, ref int y) => instance.Result = x * y);
// Modify SlowSum to measure the method execution time
Methods
.Named("SlowSum")
.WithParams <int[]>()
.Before((T instance, ref int[] values)
=> { var s = new Stopwatch(); s.Start(); return(s); })
.Catch <Exception>((instance, exception, stopwatch, values) => values.Sum())
.Finally((instance, stopwatch, values)
=> instance.Result = (int)stopwatch.ElapsedMilliseconds);
// Modify Multiply to also set the Result property to the resulting value
Methods
.Named("Add")
.WithParams <int, int>()
.Implement((instance, x, y) => x + y);
// Modify Multiply2 to also set the Result property to the resulting value
// Demonstrates use of array syntax
Methods
.Named("Multiply2")
.Before((instance, methodName, parameters)
=> instance.Result = (int)parameters[0] * (int)parameters[1]);
// Modify Divide to change the second parameter value to 1 every time
Methods
.Named("Divide")
.WithParams <int, int>()
.Before((T instance, ref int x, ref int y)
=> y = 1);
// Modify Divide2 to change the second parameter value to 1 every time
Methods
.Named("Divide2")
.Before((instance, methodName, parameters)
=> parameters[1] = 1);
// Replace implementation of Square to correct coding error
Methods
.Named("Square")
.WithParams <int>()
.Implement((instance, x)
=> x * x);
// Modify Double to double each of the input values
Methods
.Named("Double")
.WithParams <int[]>()
.After((instance, set) =>
{
for (int i = 0; i < set.Length; i++)
{
set[i] = set[i] * 2;
}
});
// Modify Double to double each of the input values
Methods
.Named("Double2")
.After((instance, methodName, parameters) =>
{
for (int i = 0; i < ((int[])parameters[0]).Length; i++)
{
((int[])parameters[0])[i] = ((int[])parameters[0])[i] * 2;
}
});
// Modify Sum to return the sum of the input values
Methods
.Named("Sum")
.WithParams <int[]>()
.After <long>((instance, set, result)
=> set.Sum());
// Modify Sum2 to return the sum of the input values
Methods
.Named("Sum2")
.After((instance, methodName, parameters, result)
=> (long)((int[])parameters[0]).Sum());
// Modify the input values but ignore the return value
Methods
.Named("Sum3")
.After((instance, methodName, parameters) =>
{
for (int i = 1; i < ((int[])parameters[0]).Length; i++)
{
((int[])parameters[0])[i] = ((int[])parameters[0])[i - 1] + ((int[])parameters[0])[i];
}
});
#endregion
#region Properties
// public int Count { get; set; }
Properties
.Add <int>("Count");
// public int Three { get { return One + Two; } }
Properties
.Add <int>("Three")
.Get((instance, property) => instance.One + instance.Two);
// public string LazyRandomName { get { if (lazyRandomName == null) lazyRandomName = "r" + new Random().Next(); return lazyRandomName; } }
Properties
.Add <string>("LazyRandomName", (instance, property) => "r" + new Random().Next());
// public int SetResult { set { Result = value; } }
Properties
.Add <int>("SetResult")
.Set((instance, property, value) => instance.Result = value);
// public int InitiallyTwelve { get; set; } = 12
Properties
.Add <int>("InitiallyTwelve")
.Initialize((instance, property) => 12);
// Modify Random1 getter set value of Random1 to GetRandom(1) before returning the underlying property value
Properties
.Named("Random1")
.BeforeGet((instance, propertyName) => instance.Random1 = instance.GetRandom(1));
// Modify Random2 to calculate a random number based on an assigned seed value
Properties
.Named("Random2")
.OfType <int>()
.AfterGet((instance, propertyName, result) => instance.GetRandom(result));
// Modify ILog.e property
Properties
.Named("Afterthought.UnitTest.Target.ILog.e")
.OfType <decimal>()
.Get((instance, propertyName) => 2.71828m);
// Modify Random5 to be just a simple getter/setter using Result property as the backing store
Properties
.Named("Random5")
.OfType <int>()
.Get((instance, propertyName) => instance.Result)
.Set((instance, propertyName, value) => instance.Result = value);
// Update Result to equal the value assigned to CopyToResult
Properties
.Named("CopyToResult")
.OfType <int>()
.BeforeSet((instance, propertyName, oldValue, value) => { instance.Result = value; return(value); });
// Modify Add to add the old value to the value being assigned
Properties
.Named("Add")
.OfType <int>()
.BeforeSet((instance, propertyName, oldValue, value) => oldValue + value);
// Initialize InitiallyThirteen to 13
Properties
.Named("InitiallyThirteen")
.OfType <int>()
.Initialize((instance, propertyName) => 13);
// Initialize ExistingLazyRandomName
Properties
.Named("ExistingLazyRandomName")
.OfType <string>()
.LazyInitialize((instance, propertyName) => "r" + new Random().Next());
#endregion
#region Interfaces
// Implement IMath interface
Implement <IMath>(
// Pi
Properties.Add <decimal>("Pi").Get((instance, property) => 3.14159m),
// Subtract(x, y)
Methods.Add("Subtract", (T instance, decimal x, decimal y) => x - y)
);
#endregion
#region Attributes
// Type Attributes
Attributes.Add <TestAttribute, Type>(typeof(string));
Attributes.Add <TestAttribute>();
Attributes.Add <TestAttribute, int>(5);
Attributes.Add <TestAttribute, string[]>(new string[] { "Testing", "Two" });
// Field Attributes
Fields
.Named("holding1")
.AddAttribute <TestAttribute, Type>(typeof(string))
.AddAttribute <TestAttribute>()
.AddAttribute <TestAttribute, int>(5)
.AddAttribute <TestAttribute, string[]>(new string[] { "Testing", "Two" });
// Constructor Attributes
Constructors
.WithParams()
.AddAttribute <TestAttribute, Type>(typeof(string))
.AddAttribute <TestAttribute>()
.AddAttribute <TestAttribute, int>(5)
.AddAttribute <TestAttribute, string[]>(new string[] { "Testing", "Two" });
// Property Attributes
Properties
.Named("Random1")
.AddAttribute <TestAttribute, Type>(typeof(string))
.AddAttribute <TestAttribute>()
.AddAttribute <TestAttribute, int>(5)
.AddAttribute <TestAttribute, string[]>(new string[] { "Testing", "Two" });
// Method Attributes
Methods
.Named("Multiply")
.AddAttribute <TestAttribute, Type>(typeof(string))
.AddAttribute <TestAttribute>()
.AddAttribute <TestAttribute, int>(5)
.AddAttribute <TestAttribute, string[]>(new string[] { "Testing", "Two" });
// EventAttributes
Events
.Named("Calculate")
.AddAttribute <TestAttribute, Type>(typeof(string))
.AddAttribute <TestAttribute>()
.AddAttribute <TestAttribute, int>(5)
.AddAttribute <TestAttribute, string[]>(new string[] { "Testing", "Two" });
#endregion
}
/// <summary>
/// Reads the APP1 section containing Exif metadata.
/// </summary>
private void ReadExifAPP1()
{
// Find the APP1 section containing Exif metadata
exifApp1 = Sections.Find(a => (a.Marker == JPEGMarker.APP1) &&
a.Header.Length >= 6 &&
(Encoding.ASCII.GetString(a.Header, 0, 6) == "Exif\0\0"));
// If there is no APP1 section, add a new one after the last APP0 section (if any).
if (exifApp1 == null)
{
int insertionIndex = Sections.FindLastIndex(a => a.Marker == JPEGMarker.APP0);
if (insertionIndex == -1)
{
insertionIndex = 0;
}
insertionIndex++;
exifApp1 = new JPEGSection(JPEGMarker.APP1);
Sections.Insert(insertionIndex, exifApp1);
if (BitConverterEx.SystemByteOrder == BitConverterEx.ByteOrder.LittleEndian)
{
ByteOrder = BitConverterEx.ByteOrder.LittleEndian;
}
else
{
ByteOrder = BitConverterEx.ByteOrder.BigEndian;
}
return;
}
byte[] header = exifApp1.Header;
SortedList <int, IFD> ifdqueue = new SortedList <int, IFD>();
makerNoteOffset = 0;
// TIFF header
int tiffoffset = 6;
if (header[tiffoffset] == 0x49 && header[tiffoffset + 1] == 0x49)
{
ByteOrder = BitConverterEx.ByteOrder.LittleEndian;
}
else if (header[tiffoffset] == 0x4D && header[tiffoffset + 1] == 0x4D)
{
ByteOrder = BitConverterEx.ByteOrder.BigEndian;
}
else
{
throw new NotValidExifFileException();
}
// TIFF header may have a different byte order
BitConverterEx.ByteOrder tiffByteOrder = ByteOrder;
if (BitConverterEx.LittleEndian.ToUInt16(header, tiffoffset + 2) == 42)
{
tiffByteOrder = BitConverterEx.ByteOrder.LittleEndian;
}
else if (BitConverterEx.BigEndian.ToUInt16(header, tiffoffset + 2) == 42)
{
tiffByteOrder = BitConverterEx.ByteOrder.BigEndian;
}
else
{
throw new NotValidExifFileException();
}
// Offset to 0th IFD
int ifd0offset = (int)BitConverterEx.ToUInt32(header, tiffoffset + 4, tiffByteOrder, BitConverterEx.SystemByteOrder);
ifdqueue.Add(ifd0offset, IFD.Zeroth);
BitConverterEx conv = new BitConverterEx(ByteOrder, BitConverterEx.SystemByteOrder);
int thumboffset = -1;
int thumblength = 0;
int thumbtype = -1;
// Read IFDs
while (ifdqueue.Count != 0)
{
int ifdoffset = tiffoffset + ifdqueue.Keys[0];
IFD currentifd = ifdqueue.Values[0];
ifdqueue.RemoveAt(0);
// Field count
ushort fieldcount = conv.ToUInt16(header, ifdoffset);
for (short i = 0; i < fieldcount; i++)
{
// Read field info
int fieldoffset = ifdoffset + 2 + 12 * i;
ushort tag = conv.ToUInt16(header, fieldoffset);
ushort type = conv.ToUInt16(header, fieldoffset + 2);
uint count = conv.ToUInt32(header, fieldoffset + 4);
byte[] value = new byte[4];
Array.Copy(header, fieldoffset + 8, value, 0, 4);
// Fields containing offsets to other IFDs
if (currentifd == IFD.Zeroth && tag == 0x8769)
{
int exififdpointer = (int)conv.ToUInt32(value, 0);
ifdqueue.Add(exififdpointer, IFD.EXIF);
}
else if (currentifd == IFD.Zeroth && tag == 0x8825)
{
int gpsifdpointer = (int)conv.ToUInt32(value, 0);
ifdqueue.Add(gpsifdpointer, IFD.GPS);
}
else if (currentifd == IFD.EXIF && tag == 0xa005)
{
int interopifdpointer = (int)conv.ToUInt32(value, 0);
ifdqueue.Add(interopifdpointer, IFD.Interop);
}
// Save the offset to maker note data
if (currentifd == IFD.EXIF && tag == 37500)
{
makerNoteOffset = conv.ToUInt32(value, 0);
}
// Calculate the bytes we need to read
uint baselength = 0;
if (type == 1 || type == 2 || type == 7)
{
baselength = 1;
}
else if (type == 3)
{
baselength = 2;
}
else if (type == 4 || type == 9)
{
baselength = 4;
}
else if (type == 5 || type == 10)
{
baselength = 8;
}
uint totallength = count * baselength;
// If field value does not fit in 4 bytes
// the value field is an offset to the actual
// field value
int fieldposition = 0;
if (totallength > 4)
{
fieldposition = tiffoffset + (int)conv.ToUInt32(value, 0);
value = new byte[totallength];
Array.Copy(header, fieldposition, value, 0, totallength);
}
// Compressed thumbnail data
if (currentifd == IFD.First && tag == 0x201)
{
thumbtype = 0;
thumboffset = (int)conv.ToUInt32(value, 0);
}
else if (currentifd == IFD.First && tag == 0x202)
{
thumblength = (int)conv.ToUInt32(value, 0);
}
// Uncompressed thumbnail data
if (currentifd == IFD.First && tag == 0x111)
{
thumbtype = 1;
// Offset to first strip
if (type == 3)
{
thumboffset = (int)conv.ToUInt16(value, 0);
}
else
{
thumboffset = (int)conv.ToUInt32(value, 0);
}
}
else if (currentifd == IFD.First && tag == 0x117)
{
thumblength = 0;
for (int j = 0; j < count; j++)
{
if (type == 3)
{
thumblength += (int)conv.ToUInt16(value, 0);
}
else
{
thumblength += (int)conv.ToUInt32(value, 0);
}
}
}
// Create the exif property from the interop data
ExifProperty prop = ExifPropertyFactory.Get(tag, type, count, value, ByteOrder, currentifd, Encoding);
Properties.Add(prop);
}
// 1st IFD pointer
int firstifdpointer = (int)conv.ToUInt32(header, ifdoffset + 2 + 12 * fieldcount);
if (firstifdpointer != 0)
{
ifdqueue.Add(firstifdpointer, IFD.First);
}
// Read thumbnail
if (thumboffset != -1 && thumblength != 0 && Thumbnail == null)
{
if (thumbtype == 0)
{
using (MemoryStream ts = new MemoryStream(header, tiffoffset + thumboffset, thumblength))
{
Thumbnail = ImageFile.FromStream(ts);
}
}
}
}
}
/// <summary>
/// Loads all properties from database into objects. If this method is re-called, it will re-query the database.
/// </summary>
/// <remarks>
/// This optimizes sql calls. This will first check if all of the properties have been loaded. If not,
/// then it will query for all property types for the current version from the db. It will then iterate over each
/// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been
/// read, we iterate over the cached property types for this ContentType and create a new property based on
/// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned
/// on all subsequent calls and is also used to return a property with calls to getProperty.
/// </remarks>
private void InitializeProperties()
{
m_LoadedProperties = new Properties();
if (this.ContentType == null)
return;
//Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int.
//This will still be an empty list since the props list is empty.
var propData = m_LoadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList();
string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId";
using (IRecordsReader dr = SqlHelper.ExecuteReader(sql,
SqlHelper.CreateParameter("@versionId", Version)))
{
while (dr.Read())
{
//add the item to our list
propData.Add(new { Id = dr.Get<int>("id"), PropertyTypeId = dr.Get<int>("propertyTypeId") });
}
}
foreach (PropertyType pt in this.ContentType.PropertyTypes)
{
if (pt == null)
continue;
//get the propertyId
var property = propData
.Where(x => x.PropertyTypeId == pt.Id)
.SingleOrDefault();
if (property == null)
continue;
var propertyId = property.Id;
Property p = null;
try
{
p = new Property(propertyId, pt);
}
catch
{
continue; //this remains from old code... not sure why we would do this?
}
m_LoadedProperties.Add(p);
}
}
public override PropertyDescriptor GetOwnProperty(string propertyName)
{
PropertyDescriptor x;
if (Properties.TryGetValue(propertyName, out x))
{
return(x);
}
var type = Target.GetType();
// look for a property
var property = type
.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)
.FirstOrDefault(p => EqualsIgnoreCasing(p.Name, propertyName));
if (property != null)
{
var descriptor = new PropertyInfoDescriptor(Engine, property, Target);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// look for a field
var field = type
.GetFields(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)
.FirstOrDefault(f => EqualsIgnoreCasing(f.Name, propertyName));
if (field != null)
{
var descriptor = new FieldInfoDescriptor(Engine, field, Target);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// if no properties were found then look for a method
var methods = type.GetMethods(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)
.Where(m => EqualsIgnoreCasing(m.Name, propertyName))
.ToArray();
if (methods.Any())
{
var descriptor = new PropertyDescriptor(new MethodInfoFunctionInstance(Engine, methods), false, true, false);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// if no methods are found check if target implemented indexing
if (type.GetProperties().FirstOrDefault(p => p.GetIndexParameters().Length != 0) != null)
{
return(new IndexDescriptor(Engine, propertyName, Target));
}
var interfaces = type.GetInterfaces();
// try to find a single explicit property implementation
var explicitProperties = (from iface in interfaces
from iprop in iface.GetProperties()
where EqualsIgnoreCasing(iprop.Name, propertyName)
select iprop).ToArray();
if (explicitProperties.Length == 1)
{
var descriptor = new PropertyInfoDescriptor(Engine, explicitProperties[0], Target);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// try to find explicit method implementations
var explicitMethods = (from iface in interfaces
from imethod in iface.GetMethods()
where EqualsIgnoreCasing(imethod.Name, propertyName)
select imethod).ToArray();
if (explicitMethods.Length > 0)
{
var descriptor = new PropertyDescriptor(new MethodInfoFunctionInstance(Engine, explicitMethods), false, true, false);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// try to find explicit indexer implementations
var explicitIndexers =
(from iface in interfaces
from iprop in iface.GetProperties()
where iprop.GetIndexParameters().Length != 0
select iprop).ToArray();
if (explicitIndexers.Length == 1)
{
return(new IndexDescriptor(Engine, explicitIndexers[0].DeclaringType, propertyName, Target));
}
return(PropertyDescriptor.Undefined);
}
/// <summary>
/// Adds a property to the collection
/// </summary>
/// <param name="key">Property key</param>
/// <param name="value">Property value</param>
public void AddProperty(string key, string value)
{
Properties.Add(new ItemProperty(key, value));
}
public ActivePlatformsAttribute(params Platform[] platforms)
{
Properties.Add("ActivePlatforms", platforms);
}
private static Properties MakeSegmentIOProperties(Dictionary<string, string> properties)
{
var prop = new Properties();
foreach (var key in properties.Keys)
{
prop.Add(key, properties[key]);
}
return prop;
return prop;
}
/// <summary>
/// Sends the exception's message and stacktrace, plus additional information the
/// program thinks may be relevant.
/// </summary>
public static void ReportException(Exception e, Dictionary<string, string> moreProperties)
{
if (!AllowTracking)
return;
var props = new Properties()
{
{ "Message", e.Message },
{ "Stack Trace", e.StackTrace }
};
if (moreProperties != null)
{
foreach (var key in moreProperties.Keys)
{
props.Add(key, moreProperties[key]);
}
}
TrackWithDefaultProperties("Exception", props);
}
