예제 #1
0
 public void AddTypedProperty1()
 {
     var col = new PropertyCollection();
     col.AddTypedProperty("foo");
     Assert.AreEqual(1, col.PropertyList.Count);
     Assert.IsTrue(col.ContainsProperty(typeof(string)));
 }
예제 #2
0
파일: Level.cs 프로젝트: zyh329/nbi
 public Level(string uniqueName, string caption, int number, PropertyCollection properties)
 {
     UniqueName = uniqueName;
     Caption = caption;
     Number = number;
     Properties = properties;
 }
예제 #3
0
        public ObjectContent(XmlNode node)
        {
            if (node.Attributes[AttributeNames.MapObjectAttributes.Name] != null)
                Name = node.Attributes[AttributeNames.MapObjectAttributes.Name].Value;

            if (node.Attributes[AttributeNames.MapObjectAttributes.Type] != null)
                Type = node.Attributes[AttributeNames.MapObjectAttributes.Type].Value;

            if (node[AttributeNames.MapObjectAttributes.Properties] != null)
                properties = new PropertyCollection(node[AttributeNames.MapObjectAttributes.Properties]);

            int x = 0, y = 0, width = 0, height = 0;

            if (node.Attributes[AttributeNames.MapObjectAttributes.X] != null)
                x = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.X].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Y] != null)
                y = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Y].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Width] != null)
                width = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Width].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Height] != null)
                height = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Height].Value);

            Bounds = new Rectangle(x, y, width, height);

            string objectPoints = String.Empty;

            if (node.Attributes[AttributeNames.MapObjectAttributes.GID] != null)
            {
                objectType = MapObjectType.Tile;
                GID = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.GID].Value);
            }
            else if (node.Attributes[AttributeNames.MapObjectAttributes.Polygon] != null)
            {
                objectType = MapObjectType.Polygon;
                objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polygon].Value;
            }
            else if (node.Attributes[AttributeNames.MapObjectAttributes.Polyline] != null)
            {
                objectType = MapObjectType.Polyline;
                objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polyline].Value;
            }

            if(!String.IsNullOrEmpty(objectPoints))
            {
                string[] splitPoints = objectPoints.Split(' ');
                foreach(string splitPoint in splitPoints)
                {
                    string[] coordinates = splitPoint.Split(',');

                    float coordinateX = 0f, coordinateY = 0f;
                    float.TryParse(coordinates[0], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateX);
                    float.TryParse(coordinates[1], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateY);

                    points.Add(new Point((int)x, (int)y));
                }
            }
        }
예제 #4
0
        internal PropertyManager(PropertyClassManager classManager, object inst)
        {
            _classManager = classManager;
            _inst = inst;

            _custom = new PropertyCollection(_classManager.RegisteredNames);
        }
예제 #5
0
파일: Level.cs 프로젝트: zyh329/nbi
 public Level(string uniqueName, string caption, int number)
 {
     UniqueName = uniqueName;
     Caption = caption;
     Number = number;
     Properties = new PropertyCollection();
 }
예제 #6
0
 /// <summary>
 /// Default constructor requires a name, the bounds of the object, the orientation of projection, and a collection of properties assigned to the object
 /// </summary>
 /// <param name="name"></param>
 /// <param name="bounds"></param>
 /// <param name="orientation"></param>
 /// <param name="properties"></param>
 public MapObject(string name, Rectangle bounds, Orientation orientation, PropertyCollection properties)
 {
     Name = name;
     Bounds = bounds;
     Orientation = orientation;
     Properties = properties;
 }
예제 #7
0
        internal ObjectLayer(ContentReader reader, ObjectRegistry registry)
            : base(reader)
        {
            _registry = registry;
            _objects = new List<ObjectInstance>();

            int objCount = reader.ReadInt32();
            for (int i = 0; i < objCount; i++) {
                int id = reader.ReadInt32();
                int dx = reader.ReadInt32();
                int dy = reader.ReadInt32();
                float rotation = reader.ReadSingle();
                float scaleX = reader.ReadSingle();
                float scaleY = reader.ReadSingle();

                PropertyCollection properties = new PropertyCollection(reader);

                _objects.Add(new ObjectInstance(_registry.GetObjectPool(id), id, dx, dy) {
                    Rotation = rotation,
                    ScaleX = scaleX,
                    ScaleY = scaleY,
                    Properties = properties,
                });
            }
        }
예제 #8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Mesh"/> class.
 /// </summary>
 public Mesh()
 {
     VertexBuffers = new List<VertexBuffer>();
     IndexBuffers = new List<IndexBuffer>();
     MeshParts = new List<MeshPart>();
     Properties = new PropertyCollection();
 }
예제 #9
0
        public TileSheetPropertiesCommand(TileSheet tileSheet,
            string newId, string newDescription,
            Size newTileSize, Size newMargin, Size newSpacing,
            Size newSheetSize, string newImageSource,
            PropertyCollection newProperties)
        {
            m_tileSheet = tileSheet;

            m_oldId = tileSheet.Id;
            m_oldDescription = tileSheet.Description;
            m_oldTileSize = tileSheet.TileSize;
            m_oldMargin = tileSheet.Margin;
            m_oldSpacing = tileSheet.Spacing;
            m_oldSheetSize = tileSheet.SheetSize;
            m_oldImageSource = tileSheet.ImageSource;
            m_oldProperties = new PropertyCollection(tileSheet.Properties);

            m_newId = newId;
            m_newDescription = newDescription;
            m_newTileSize = newTileSize;
            m_newMargin = newMargin;
            m_newSpacing = newSpacing;
            m_newSheetSize = newSheetSize;
            m_newImageSource = newImageSource;
            m_newProperties = newProperties;
        }
예제 #10
0
 internal MapObject(string name, string type, Rectangle location, PropertyCollection properties)
 {
     Name = name;
     Type = type;
     Location = location;
     Properties = properties;
 }
예제 #11
0
        public override ControlInfo OnCreateSaveConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultSaveConfigUI(props);

            configUI.SetPropertyControlValue(
                PropertyNames.BitDepth,
                ControlInfoPropertyNames.DisplayName,
                PdnResources.GetString("PngFileType.ConfigUI.BitDepth.DisplayName"));

            PropertyControlInfo bitDepthPCI = configUI.FindControlForPropertyName(PropertyNames.BitDepth);
            bitDepthPCI.SetValueDisplayName(PngBitDepthUIChoices.AutoDetect, PdnResources.GetString("PngFileType.ConfigUI.BitDepth.AutoDetect.DisplayName"));
            bitDepthPCI.SetValueDisplayName(PngBitDepthUIChoices.Bpp32, PdnResources.GetString("PngFileType.ConfigUI.BitDepth.Bpp32.DisplayName"));
            bitDepthPCI.SetValueDisplayName(PngBitDepthUIChoices.Bpp24, PdnResources.GetString("PngFileType.ConfigUI.BitDepth.Bpp24.DisplayName"));
            bitDepthPCI.SetValueDisplayName(PngBitDepthUIChoices.Bpp8, PdnResources.GetString("PngFileType.ConfigUI.BitDepth.Bpp8.DisplayName"));

            configUI.SetPropertyControlType(PropertyNames.BitDepth, PropertyControlType.RadioButton);

            configUI.SetPropertyControlValue(
                PropertyNames.DitherLevel,
                ControlInfoPropertyNames.DisplayName,
                PdnResources.GetString("PngFileType.ConfigUI.DitherLevel.DisplayName"));

            configUI.SetPropertyControlValue(
                PropertyNames.Threshold,
                ControlInfoPropertyNames.DisplayName,
                PdnResources.GetString("PngFileType.ConfigUI.Threshold.DisplayName"));

            configUI.SetPropertyControlValue(
                PropertyNames.Threshold,
                ControlInfoPropertyNames.Description,
                PdnResources.GetString("PngFileType.ConfigUI.Threshold.Description"));

            return configUI;
        }
예제 #12
0
 public MapEntity()
 {
     Layer = MapLayer.Default;
     FourCC = string.Empty;
     LayerCanChange = false;
     Fields = new PropertyCollection();
 }
예제 #13
0
        public Layer(XElement node)
        {
            //string Type = node.Name;
            Name = node.Attribute("name").Value;
            if (node.Attribute("width") != null)
                Width = int.Parse(node.Attribute("width").Value, CultureInfo.InvariantCulture);
            else
                Width = 0;
            if (node.Attribute("height") != null)
                Height = int.Parse(node.Attribute("height").Value, CultureInfo.InvariantCulture);
            else
                Height = 0;

            if (node.Attribute("opacity") != null)
            {
                Opacity = float.Parse(node.Attribute("opacity").Value, CultureInfo.InvariantCulture);
            }
            else
                Opacity = 1;

            if (node.Attribute("visible") != null)
            {
                Visible = int.Parse(node.Attribute("visible").Value, CultureInfo.InvariantCulture) == 1;
            }
            else
                Visible = true;

            XElement propertiesNode = node.Element("properties");
            if (propertiesNode != null)
            {
                Properties = new PropertyCollection(propertiesNode);
            }
        }
예제 #14
0
        /// <summary>
        /// Constructor for creating a Content object
        /// </summary>
        /// <param name="name">Name of the content</param>
        /// <param name="parentId">Id of the Parent content</param>
        /// <param name="contentType">ContentType for the current Content object</param>
        /// <param name="properties">Collection of properties</param>
        public Content(string name, int parentId, IContentType contentType, PropertyCollection properties) 
			: base(name, parentId, contentType, properties)
        {
            Mandate.ParameterNotNull(contentType, "contentType");

            _contentType = contentType;
        }
예제 #15
0
        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Scale, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("CloudsEffect.ConfigDialog.ScaleLabel"));

            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("CloudsEffect.ConfigDialog.RoughnessLabel"));
            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.SliderLargeChange, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.SliderSmallChange, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.UpDownIncrement, 0.01);

            PropertyControlInfo blendOpControl = configUI.FindControlForPropertyName(PropertyNames.BlendOp);
            blendOpControl.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = PdnResources.GetString("CloudsEffect.ConfigDialog.BlendModeHeader.Text");

            Type[] blendOpTypes = UserBlendOps.GetBlendOps();
            foreach (Type blendOpType in blendOpTypes)
            {
                string blendOpDisplayName = UserBlendOps.GetBlendOpFriendlyName(blendOpType);
                blendOpControl.SetValueDisplayName(blendOpType, blendOpDisplayName);
            }

            configUI.SetPropertyControlType(PropertyNames.Seed, PropertyControlType.IncrementButton);
            configUI.SetPropertyControlValue(PropertyNames.Seed, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("CloudsEffect.ConfigDialog.SeedHeader.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Seed, ControlInfoPropertyNames.ButtonText, PdnResources.GetString("CloudsEffect.ConfigDialog.ReseedButton.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Seed, ControlInfoPropertyNames.Description, PdnResources.GetString("CloudsEffect.ConfigDialog.UsageLabel"));

            return configUI;
        }
예제 #16
0
        public MapContent(string filePath, Renderer renderer, string contentRoot)
        {
            XmlDocument document = new XmlDocument();
            document.Load(filePath);

            XmlNode mapNode = document[AttributeNames.MapAttributes.Map];

            Version = mapNode.Attributes[AttributeNames.MapAttributes.Version].Value;
            Orientation = (Orientation)Enum.Parse(typeof(Orientation), mapNode.Attributes[AttributeNames.MapAttributes.Orientation].Value, true);
            Width = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.Width].Value);
            Height = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.Height].Value);
            TileWidth = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.TileWidth].Value);
            TileHeight = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.TileHeight].Value);

            XmlNode propertiesNode = document.SelectSingleNode(AttributeNames.MapAttributes.MapProperties);
            if (propertiesNode != null)
                properties = new PropertyCollection(propertiesNode);

            BuildTileSets(document);

            BuildLayers(document);

            BuildTileSetTextures(renderer, contentRoot);

            GenerateTileSourceRectangles();
        }
예제 #17
0
        internal Tileset(ContentReader reader)
            : this()
        {
            _manager = reader.ContentManager;

            int version = reader.ReadInt16();
            int id = reader.ReadInt16();

            TileWidth = reader.ReadInt16();
            TileHeight = reader.ReadInt16();
            string texAsset = reader.ReadString();

            Properties = new PropertyCollection(reader);

            int tileCount = reader.ReadInt16();
            for (int i = 0; i < tileCount; i++) {
                int tileId = reader.ReadInt16();
                int tileX = reader.ReadInt16();
                int tileY = reader.ReadInt16();

                Tile tile = new Tile(tileId, this, tileX, tileY)
                {
                    Properties = new PropertyCollection(reader),
                };
                _tiles.Add(tileId, tile);
            }

            _texture = _manager.Load<Texture2D>(texAsset);
        }
        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Amount1, ControlInfoPropertyNames.DisplayName, "Scale");
            configUI.SetPropertyControlValue(PropertyNames.Amount1, ControlInfoPropertyNames.SliderLargeChange, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Amount1, ControlInfoPropertyNames.SliderSmallChange, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Amount1, ControlInfoPropertyNames.UpDownIncrement, 0.01);
            configUI.SetPropertyControlValue(PropertyNames.Amount2, ControlInfoPropertyNames.DisplayName, "Line Width");
            configUI.SetPropertyControlValue(PropertyNames.Amount3, ControlInfoPropertyNames.DisplayName, "Line Color");
            configUI.SetPropertyControlValue(PropertyNames.Amount3, ControlInfoPropertyNames.Description, "Transparent");
            configUI.SetPropertyControlValue(PropertyNames.Amount4, ControlInfoPropertyNames.DisplayName, string.Empty);
            configUI.SetPropertyControlType(PropertyNames.Amount4, PropertyControlType.ColorWheel);
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.DisplayName, "Offset");
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.SliderSmallChangeX, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.SliderLargeChangeX, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.UpDownIncrementX, 0.01);
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.SliderSmallChangeY, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.SliderLargeChangeY, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.UpDownIncrementY, 0.01);
            Rectangle selection5 = EnvironmentParameters.GetSelection(EnvironmentParameters.SourceSurface.Bounds).GetBoundsInt();
            ImageResource imageResource5 = ImageResource.FromImage(EnvironmentParameters.SourceSurface.CreateAliasedBitmap(selection5));
            configUI.SetPropertyControlValue(PropertyNames.Amount5, ControlInfoPropertyNames.StaticImageUnderlay, imageResource5);

            return configUI;
        }
예제 #19
0
        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("TwistEffect.TwistAmount.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.UseExponentialScale, true);

            configUI.SetPropertyControlValue(PropertyNames.Size, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("TwistEffect.TwistSize.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Size, ControlInfoPropertyNames.SliderSmallChange, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Size, ControlInfoPropertyNames.SliderLargeChange, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Size, ControlInfoPropertyNames.UpDownIncrement, 0.01);

            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("TwistEffect.Offset.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeX, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeX, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementX, 0.01);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeY, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeY, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementY, 0.01);

            Surface sourceSurface = this.EnvironmentParameters.SourceSurface;
            Bitmap bitmap = sourceSurface.CreateAliasedBitmap();
            ImageResource imageResource = ImageResource.FromImage(bitmap);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.StaticImageUnderlay, imageResource);

            configUI.SetPropertyControlValue(PropertyNames.Quality, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("TwistEffect.Antialias.Text"));

            return configUI;
        }
예제 #20
0
 internal Settings(StyleCopCore core)
 {
     this.globalSettings = new PropertyCollection();
     this.parserSettings = new Dictionary<string, AddInPropertyCollection>();
     this.analyzerSettings = new Dictionary<string, AddInPropertyCollection>();
     this.core = core;
 }
예제 #21
0
        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Angle, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("RadialBlurEffect.ConfigDialog.RadialLabel"));
            configUI.FindControlForPropertyName(PropertyNames.Angle).ControlType.Value = PropertyControlType.AngleChooser;

            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("RadialBlurEffect.ConfigDialog.OffsetLabel"));
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeX, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeX, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementX, 0.01);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeY, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeY, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementY, 0.01);

            Surface sourceSurface = this.EnvironmentParameters.SourceSurface;
            Bitmap bitmap = sourceSurface.CreateAliasedBitmap();
            ImageResource imageResource = ImageResource.FromImage(bitmap);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.StaticImageUnderlay, imageResource);

            configUI.SetPropertyControlValue(PropertyNames.Quality, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("RadialBlurEffect.ConfigDialog.QualityLabel"));
            configUI.SetPropertyControlValue(PropertyNames.Quality, ControlInfoPropertyNames.Description, PdnResources.GetString("RadialBlurEffect.ConfigDialog.QualityDescription"));

            return configUI;
        }
예제 #22
0
        protected virtual void ReadDetail(XPathNavigator navigator, PropertyCollection collection, ReadingJournal journal)
        {
            Dictionary<string, string> attributes = GetAttributes(navigator);
            Type type = attributes["typeName"].ToType();

            if (type != typeof(ContentItem))
            {
                collection.Add(Parse(navigator.Value, type));
            }
            else
            {
                int referencedItemID = int.Parse(navigator.Value);
                ContentItem referencedItem = journal.Find(referencedItemID);
                if (referencedItem != null)
                    collection.Add(referencedItem);
                else
                    journal.ItemAdded += (sender, e) =>
            {
                if (e.AffectedItem.ID == referencedItemID)
                {
                    collection.Add(e.AffectedItem);
                }
            };
            }
        }
예제 #23
0
        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = base.OnCreateConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.Amount.DisplayName"));
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.UseExponentialScale, true);
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.SliderLargeChange, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.SliderSmallChange, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.UpDownIncrement, 0.01);

            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.Offset.DisplayName"));
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeX, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeX, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementX, 0.01);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeY, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeY, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementY, 0.01);

            Rectangle selection = this.EnvironmentParameters.GetSelection(base.EnvironmentParameters.SourceSurface.Bounds).GetBoundsInt();
            ImageResource propertyValue = ImageResource.FromImage(base.EnvironmentParameters.SourceSurface.CreateAliasedBitmap(selection));
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.StaticImageUnderlay, propertyValue);

            configUI.SetPropertyControlValue(PropertyNames.EdgeBehavior, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.DisplayName"));

            PropertyControlInfo edgeBehaviorPCI = configUI.FindControlForPropertyName(PropertyNames.EdgeBehavior);
            edgeBehaviorPCI.SetValueDisplayName(WarpEdgeBehavior.Clamp, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.Clamp.DisplayName"));
            edgeBehaviorPCI.SetValueDisplayName(WarpEdgeBehavior.Reflect, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.Reflect.DisplayName"));
            edgeBehaviorPCI.SetValueDisplayName(WarpEdgeBehavior.Wrap, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.Wrap.DisplayName"));

            configUI.SetPropertyControlValue(PropertyNames.Quality, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.Quality.DisplayName"));

            return configUI;
        }
예제 #24
0
파일: Tile.cs 프로젝트: GarethIW/Hunted
 internal Tile(Texture2D texture, Rectangle source, PropertyCollection properties, bool[] collision)
 {
     Texture = texture;
     Source = source;
     Properties = properties;
     CollisionData = collision;
 }
예제 #25
0
 private static void AddBooleanProperty(string propertyName, bool value, PropertyCollection properties, PropertyDescriptorCollection propertyDescriptors)
 {
     PropertyDescriptor<bool> propertyDescriptor = propertyDescriptors[propertyName] as PropertyDescriptor<bool>;
     if (propertyDescriptor != null)
     {
         properties.Add(new BooleanProperty(propertyDescriptor, value));
     }
 }
예제 #26
0
 internal MapObject(string name, string type, Rectangle location, List<Point> linePoints, PropertyCollection properties)
 {
     Name = name;
     Type = type;
     Location = location;
     Properties = properties;
     LinePoints = linePoints;
 }
예제 #27
0
 static void TestRemove(ref PropertyCollection collection, int count)
 {
     for (int i = 0; i < count; i++)
     {
         collection.RemoveProperty(i);
         Assert.AreEqual(collection.GetProperty(i), null);
     }
 }
예제 #28
0
        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("SharpenEffect.ConfigDialog.SliderLabel"));

            return configUI;
        }
예제 #29
0
 static void TestAdd(ref PropertyCollection collection, int count)
 {
     for (int i = 0; i < count; i++)
     {
         collection.SetProperty(i, i);
         Assert.AreEqual(collection.GetProperty(i), i);
     }            
 }
예제 #30
0
        public void TryGetPropertySafe_NotFound()
        {
            var col = new PropertyCollection();
            var key = new object();

            string value;
            Assert.IsFalse(col.TryGetPropertySafe(key, out value));
        }
 /// <summary>
 ///     <para>Initializes an instance of the <see cref="TraceContextComponent"/> class.</para>
 /// </summary>
 /// <param name="configuration">
 /// Configuration properties.
 /// </param>
 public TraceContextComponent(PropertyCollection configuration)
     : base(configuration)
 {
     maxLogSize = (ulong)configuration.Read("MaxLogSize");
     logPath    = (string)configuration.Read("LogPath");
 }
예제 #32
0
 public TextBufferStub(String contentType)
 {
     ContentType = new ContentTypeStub(contentType);
     Properties  = new PropertyCollection();
 }
예제 #33
0
파일: Field.cs 프로젝트: rjankovic/deskmin
 public FKField(int fieldId, string column, int typeId, string typeName, int panelId, IFK fk,
                PropertyCollection attr = null, PropertyCollection rules = null)
     : base(fieldId, column, typeId, typeName, panelId, attr, rules)
 {
     this.fk = fk;
 }
예제 #34
0
        public static Tuple <Mock <ITextView>, MockRepository> CreateTextViewWithVisibleLines(
            ITextBuffer textBuffer,
            int startLine,
            int?endLine            = null,
            int?caretPosition      = null,
            MockRepository factory = null)
        {
            factory = factory ?? new MockRepository(MockBehavior.Strict);
            var endLineValue       = endLine ?? startLine;
            var caretPositionValue = caretPosition ?? textBuffer.GetLine(startLine).Start.Position;
            var caret = factory.Create <ITextCaret>();

            caret.SetupGet(x => x.Position).Returns(
                new CaretPosition(
                    new VirtualSnapshotPoint(textBuffer.GetPoint(caretPositionValue)),
                    factory.Create <IMappingPoint>().Object,
                    PositionAffinity.Predecessor));

            var firstLine = factory.Create <ITextViewLine>();

            firstLine.SetupGet(x => x.Start).Returns(textBuffer.GetLine(startLine).Start);

            var lastLine = factory.Create <ITextViewLine>();

            lastLine.SetupGet(x => x.End).Returns(textBuffer.GetLine(endLineValue).End);

            var lines = factory.Create <ITextViewLineCollection>();

            lines.SetupGet(x => x.FirstVisibleLine).Returns(firstLine.Object);
            lines.SetupGet(x => x.LastVisibleLine).Returns(lastLine.Object);

            var visualBuffer  = CreateTextBuffer(factory: factory);
            var textViewModel = factory.Create <ITextViewModel>();

            textViewModel.SetupGet(x => x.VisualBuffer).Returns(visualBuffer.Object);

            var textDataModel = CreateTextDataModel(textBuffer, factory);

            // When creating the CommonOperations linked to the textview,
            // the roles are checked for the outlining manager.
            // Pretend we don't support anything
            var roles = factory.Create <ITextViewRoleSet>();

            roles.Setup(x => x.Contains(It.IsAny <String>())).Returns(false);

            var properties  = new PropertyCollection();
            var textView    = factory.Create <ITextView>();
            var options     = factory.Create <IEditorOptions>();
            var bufferGraph = factory.Create <IBufferGraph>();

            textView.SetupGet(x => x.TextBuffer).Returns(textBuffer);
            textView.SetupGet(x => x.TextViewLines).Returns(lines.Object);
            textView.SetupGet(x => x.Caret).Returns(caret.Object);
            textView.SetupGet(x => x.InLayout).Returns(false);
            textView.SetupGet(x => x.TextSnapshot).Returns(() => textBuffer.CurrentSnapshot);
            textView.SetupGet(x => x.Properties).Returns(properties);
            textView.SetupGet(x => x.BufferGraph).Returns(bufferGraph.Object);
            textView.SetupGet(x => x.TextViewModel).Returns(textViewModel.Object);
            textView.SetupGet(x => x.VisualSnapshot).Returns(visualBuffer.Object.CurrentSnapshot);
            textView.SetupGet(x => x.Roles).Returns(roles.Object);
            textView.SetupGet(x => x.Options).Returns(options.Object);
            textView.SetupGet(x => x.TextDataModel).Returns(textDataModel.Object);
            return(Tuple.Create(textView, factory));
        }
예제 #35
0
 protected override void OnCustomizeConfigUIWindowProperties(PropertyCollection props)
 {
     base.OnCustomizeConfigUIWindowProperties(props);
     //props[ControlInfoPropertyNames.WindowIsSizable].Value = true;
 }
예제 #36
0
 public UserInfoRecordDescription(string channel)
 {
     Channel    = channel;
     Properties = new PropertyCollection <object>(0);
 }
        public override ControlInfo OnCreateSaveConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultSaveConfigUI(props);

            PropertyControlInfo formatPCI = configUI.FindControlForPropertyName(PropertyNames.FileFormat);

            formatPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = string.Empty;
            formatPCI.SetValueDisplayName(DdsFileFormat.BC1, this.strings.GetString("DdsFileFormat_BC1"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC1Srgb, this.strings.GetString("DdsFileFormat_BC1Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC2, this.strings.GetString("DdsFileFormat_BC2"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC2Srgb, this.strings.GetString("DdsFileFormat_BC2Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC3, this.strings.GetString("DdsFileFormat_BC3"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC3Srgb, this.strings.GetString("DdsFileFormat_BC3Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC4Unsigned, this.strings.GetString("DdsFileFormat_BC4Unsigned"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC5Unsigned, this.strings.GetString("DdsFileFormat_BC5Unsigned"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC5Signed, this.strings.GetString("DdsFileFormat_BC5Signed"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC6HUnsigned, this.strings.GetString("DdsFileFormat_BC6HUnsigned"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC7, this.strings.GetString("DdsFileFormat_BC7"));
            formatPCI.SetValueDisplayName(DdsFileFormat.BC7Srgb, this.strings.GetString("DdsFileFormat_BC7Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B8G8R8A8, this.strings.GetString("DdsFileFormat_B8G8R8A8"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B8G8R8A8Srgb, this.strings.GetString("DdsFileFormat_B8G8R8A8Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B8G8R8X8, this.strings.GetString("DdsFileFormat_B8G8R8X8"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B8G8R8X8Srgb, this.strings.GetString("DdsFileFormat_B8G8R8X8Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.R8G8B8A8, this.strings.GetString("DdsFileFormat_R8G8B8A8"));
            formatPCI.SetValueDisplayName(DdsFileFormat.R8G8B8A8Srgb, this.strings.GetString("DdsFileFormat_R8G8B8A8Srgb"));
            formatPCI.SetValueDisplayName(DdsFileFormat.R8G8B8X8, this.strings.GetString("DdsFileFormat_R8G8B8X8"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B5G5R5A1, this.strings.GetString("DdsFileFormat_B5G5R5A1"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B4G4R4A4, this.strings.GetString("DdsFileFormat_B4G4R4A4"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B5G6R5, this.strings.GetString("DdsFileFormat_B5G6R5"));
            formatPCI.SetValueDisplayName(DdsFileFormat.B8G8R8, this.strings.GetString("DdsFileFormat_B8G8R8"));
            formatPCI.SetValueDisplayName(DdsFileFormat.R8Unsigned, this.strings.GetString("DdsFileFormat_R8Unsigned"));
            formatPCI.SetValueDisplayName(DdsFileFormat.R8G8Unsigned, this.strings.GetString("DdsFileFormat_R8G8Unsigned"));
            formatPCI.SetValueDisplayName(DdsFileFormat.R8G8Signed, this.strings.GetString("DdsFileFormat_R8G8Signed"));

            PropertyControlInfo compresionModePCI = configUI.FindControlForPropertyName(PropertyNames.BC7CompressionSpeed);

            compresionModePCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = this.strings.GetString("BC7CompressionSpeed_DisplayName");
            compresionModePCI.SetValueDisplayName(BC7CompressionSpeed.Fast, this.strings.GetString("BC7CompressionSpeed_Fast"));
            compresionModePCI.SetValueDisplayName(BC7CompressionSpeed.Medium, this.strings.GetString("BC7CompressionSpeed_Medium"));
            compresionModePCI.SetValueDisplayName(BC7CompressionSpeed.Slow, this.strings.GetString("BC7CompressionSpeed_Slow"));

            PropertyControlInfo errorMetricPCI = configUI.FindControlForPropertyName(PropertyNames.ErrorMetric);

            errorMetricPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = this.strings.GetString("ErrorMetric_DisplayName");
            errorMetricPCI.ControlType.Value = PropertyControlType.RadioButton;
            errorMetricPCI.SetValueDisplayName(DdsErrorMetric.Perceptual, this.strings.GetString("ErrorMetric_Perceptual"));
            errorMetricPCI.SetValueDisplayName(DdsErrorMetric.Uniform, this.strings.GetString("ErrorMetric_Uniform"));

            PropertyControlInfo cubemapPCI = configUI.FindControlForPropertyName(PropertyNames.CubeMap);

            cubemapPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = string.Empty;
            cubemapPCI.ControlProperties[ControlInfoPropertyNames.Description].Value = this.strings.GetString("CubeMap_Description");

            PropertyControlInfo generateMipPCI = configUI.FindControlForPropertyName(PropertyNames.GenerateMipMaps);

            generateMipPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = string.Empty;
            generateMipPCI.ControlProperties[ControlInfoPropertyNames.Description].Value = this.strings.GetString("GenerateMipMaps_Description");

            PropertyControlInfo mipResamplingPCI = configUI.FindControlForPropertyName(PropertyNames.MipMapResamplingAlgorithm);

            mipResamplingPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = string.Empty;
            mipResamplingPCI.SetValueDisplayName(ResamplingAlgorithm.NearestNeighbor, this.strings.GetString("ResamplingAlgorithm_NearestNeighbor"));
            mipResamplingPCI.SetValueDisplayName(ResamplingAlgorithm.Bicubic, this.strings.GetString("ResamplingAlgorithm_Bicubic"));
            mipResamplingPCI.SetValueDisplayName(ResamplingAlgorithm.Bilinear, this.strings.GetString("ResamplingAlgorithm_Bilinear"));
            mipResamplingPCI.SetValueDisplayName(ResamplingAlgorithm.Fant, this.strings.GetString("ResamplingAlgorithm_Fant"));
            mipResamplingPCI.SetValueDisplayName(ResamplingAlgorithm.SuperSampling, this.strings.GetString("ResamplingAlgorithm_SuperSampling"));

            PropertyControlInfo forumLinkPCI = configUI.FindControlForPropertyName(PropertyNames.ForumLink);

            forumLinkPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = this.strings.GetString("ForumLink_DisplayName");
            forumLinkPCI.ControlProperties[ControlInfoPropertyNames.Description].Value = this.strings.GetString("ForumLink_Description");

            PropertyControlInfo githubLinkPCI = configUI.FindControlForPropertyName(PropertyNames.GitHubLink);

            githubLinkPCI.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = string.Empty;
            githubLinkPCI.ControlProperties[ControlInfoPropertyNames.Description].Value = "GitHub"; // GitHub is a brand name that should not be localized.

            return(configUI);
        }
예제 #38
0
 /// <summary>
 /// Appends its data points into new or existing property collection
 /// </summary>
 /// <param name="data">Property collection to add data into</param>
 /// <returns>
 /// Updated or newly created property collection
 /// </returns>
 /// <exception cref="NotImplementedException"></exception>
 PropertyCollection IAppendDataFields.AppendDataFields(PropertyCollection data)
 {
     return(AppendDataFields(data as PropertyCollectionExtended));
 }
예제 #39
0
                protected void AddMessageBoxStyle(XmlNode XMLMessageBox)
                {
                    string name = Xml.Att(XMLMessageBox.Attributes["name"]);

                    // Empty style name is the same as "default"
                    if (name == null || name == "")
                    {
                        name = "__defaultMessageBox__";
                    }

                    PropertyCollection msgStyle = new PropertyCollection();

                    string style = Xml.Att(XMLMessageBox.Attributes["style"]);

                    msgStyle.Set("width", styleSheet.Apply(style, "width", XMLMessageBox.Attributes));
                    msgStyle.Set("y", styleSheet.Apply(style, "y", XMLMessageBox.Attributes));
                    msgStyle.Set("alignV", styleSheet.Apply(style, "alignV", XMLMessageBox.Attributes));

                    foreach (XmlNode element in XMLMessageBox.ChildNodes)
                    {
                        style = Xml.Att(element.Attributes["style"]);

                        switch (element.Name)
                        {
                        case "title":

                            msgStyle.Set("titleFontSize", styleSheet.Apply(style, "fontSize", element.Attributes));
                            msgStyle.Set("titleFontFace", styleSheet.Apply(style, "fontFace", element.Attributes));
                            msgStyle.Set("titlePaddingTop", styleSheet.Apply(style, "paddingTop", element.Attributes));

                            break;

                        case "body":

                            msgStyle.Set("bodyFontSize", styleSheet.Apply(style, "fontSize", element.Attributes));
                            msgStyle.Set("bodyFontFace", styleSheet.Apply(style, "fontFace", element.Attributes));
                            msgStyle.Set("bodyPaddingTop", styleSheet.Apply(style, "paddingTop", element.Attributes));

                            break;

                        case "background":

                            msgStyle.Set("backgroundColour", styleSheet.Apply(style, "colour", element.Attributes));
                            msgStyle.Set("backgroundSrc", styleSheet.Apply(style, "src", element.Attributes));
                            break;

                        case "button":

                            msgStyle.Set("buttonPaddingTop", styleSheet.Apply(style, "paddingTop", element.Attributes));
                            msgStyle.Set("buttonY", styleSheet.Apply(style, "y", element.Attributes));
                            msgStyle.Set("buttonWidth", styleSheet.Apply(style, "width", element.Attributes));
                            msgStyle.Set("buttonHeight", styleSheet.Apply(style, "height", element.Attributes));

                            foreach (XmlNode child in element.ChildNodes)
                            {
                                style = Xml.Att(child.Attributes["style"]);

                                if (child.Name == "text")
                                {
                                    //msgStyle.Set("buttonTextAlign", styleSheet.Apply(style, "textAlign", child.Attributes));
                                    msgStyle.Set("buttonFontSize", styleSheet.Apply(style, "fontSize", child.Attributes));
                                    msgStyle.Set("buttonFontFace", styleSheet.Apply(style, "fontFace", child.Attributes));
                                }
                                else if (child.Name == "background")
                                {
                                    msgStyle.Set("buttonBackgroundSrc", styleSheet.Apply(style, "src", child.Attributes));
                                    msgStyle.Set("buttonBackgroundColour", styleSheet.Apply(style, "colour", child.Attributes));
                                    //msgStyle.Set("buttonBackgroundScale", styleSheet.Apply(style, "scale", child.Attributes));
                                }
                                else
                                {
                                    throw new Exception("Button has unexpected element: " + element.Name);
                                }
                            }

                            break;

                        default: throw new Exception(string.Format("Encountered unknown messagebox child: {0}", element.Name));
                        }
                    }

                    styleSheet.Add(name, msgStyle);
                }
예제 #40
0
        protected override void OnSetRenderInfo(PropertyBasedEffectConfigToken token, RenderArgs dstArgs, RenderArgs srcArgs)
        {
            int blurRadius = token.GetProperty <Int32Property>(PropertyNames.BlurRadius).Value;
            int brightness = token.GetProperty <Int32Property>(PropertyNames.Brightness).Value;
            Pair <double, double> position = token.GetProperty <DoubleVectorProperty>(PropertyNames.Position).Value;

            this.keepOriginal = token.GetProperty <BooleanProperty>(PropertyNames.KeepOriginal).Value;

            Rectangle selection = this.EnvironmentParameters.SelectionBounds;

            if (this.trimmedBounds.IsEmpty)
            {
                this.trimmedBounds = GetTrimmedBounds(srcArgs.Surface, selection);
            }

            float ratio     = (float)selection.Width / selection.Height;
            Size  ratioSize = new Size(this.trimmedBounds.Width, this.trimmedBounds.Height);

            if (ratioSize.Width < ratioSize.Height * ratio)
            {
                ratioSize.Height = (int)Math.Round(this.trimmedBounds.Width / ratio);
            }
            else if (ratioSize.Width > ratioSize.Height * ratio)
            {
                ratioSize.Width = (int)Math.Round(this.trimmedBounds.Height * ratio);
            }

            PointF    offsetForCenter = new PointF(Math.Abs(ratioSize.Width - this.trimmedBounds.Width) / 2f, Math.Abs(ratioSize.Height - this.trimmedBounds.Height) / 2f);
            Rectangle srcRect         = new Rectangle
            {
                X      = (int)Math.Round(this.trimmedBounds.X + offsetForCenter.X + (position.First * offsetForCenter.X)),
                Y      = (int)Math.Round(this.trimmedBounds.Y + offsetForCenter.Y + (position.Second * offsetForCenter.Y)),
                Width  = ratioSize.Width,
                Height = ratioSize.Height
            };

            if (this.enlargedSurface == null)
            {
                this.enlargedSurface = new Surface(selection.Size);
            }

            using (Surface ratioSurface = new Surface(ratioSize))
            {
                ratioSurface.CopySurface(srcArgs.Surface, Point.Empty, srcRect);
                this.enlargedSurface.FitSurface(ResamplingAlgorithm.Bicubic, ratioSurface);
            }

            if (selection.Size != srcArgs.Surface.Size)
            {
                if (this.clampedSurface == null)
                {
                    this.clampedSurface = new Surface(srcArgs.Surface.Size);
                }

                for (int y = Math.Max(0, selection.Top - 200); y < Math.Min(this.clampedSurface.Height, selection.Bottom + 200); y++)
                {
                    if (this.IsCancelRequested)
                    {
                        return;
                    }
                    for (int x = Math.Max(0, selection.Left - 200); x < Math.Min(this.clampedSurface.Width, selection.Right + 200); x++)
                    {
                        this.clampedSurface[x, y] = this.enlargedSurface.GetBilinearSampleClamped(x - selection.Left, y - selection.Top);
                    }
                }
            }
            else
            {
                this.clampedSurface = this.enlargedSurface;
            }

            if (this.effectsSurface == null)
            {
                this.effectsSurface = new Surface(srcArgs.Surface.Size);
            }

            // Setup for calling the Gaussian Blur effect
            PropertyCollection             blurProps      = this.blurEffect.CreatePropertyCollection();
            PropertyBasedEffectConfigToken BlurParameters = new PropertyBasedEffectConfigToken(blurProps);

            BlurParameters.SetPropertyValue(GaussianBlurEffect.PropertyNames.Radius, blurRadius);
            this.blurEffect.SetRenderInfo(BlurParameters, new RenderArgs(this.effectsSurface), new RenderArgs(this.clampedSurface));

            // Setup for calling the Brightness and Contrast Adjustment function
            PropertyCollection             bacProps      = this.bacAdjustment.CreatePropertyCollection();
            PropertyBasedEffectConfigToken bacParameters = new PropertyBasedEffectConfigToken(bacProps);

            bacParameters.SetPropertyValue(BrightnessAndContrastAdjustment.PropertyNames.Brightness, brightness);
            bacParameters.SetPropertyValue(BrightnessAndContrastAdjustment.PropertyNames.Contrast, 0);
            this.bacAdjustment.SetRenderInfo(bacParameters, new RenderArgs(this.effectsSurface), new RenderArgs(this.effectsSurface));

            base.OnSetRenderInfo(token, dstArgs, srcArgs);
        }
예제 #41
0
        private static string GenerateDataTablePropertyArray(DataTableProcessor dataTableProcessor)
        {
            List <PropertyCollection> propertyCollections = new List <PropertyCollection>();

            for (int i = 0; i < dataTableProcessor.RawColumnCount; i++)
            {
                if (dataTableProcessor.IsCommentColumn(i))
                {
                    // 注释列
                    continue;
                }

                if (dataTableProcessor.IsIdColumn(i))
                {
                    // 编号列
                    continue;
                }

                string name = dataTableProcessor.GetName(i);
                if (!EndWithNumberRegex.IsMatch(name))
                {
                    continue;
                }

                string propertyCollectionName = EndWithNumberRegex.Replace(name, string.Empty);
                int    id = int.Parse(EndWithNumberRegex.Match(name).Value);

                PropertyCollection propertyCollection = null;
                foreach (PropertyCollection pc in propertyCollections)
                {
                    if (pc.Name == propertyCollectionName)
                    {
                        propertyCollection = pc;
                        break;
                    }
                }

                if (propertyCollection == null)
                {
                    propertyCollection = new PropertyCollection(propertyCollectionName, dataTableProcessor.GetLanguageKeyword(i));
                    propertyCollections.Add(propertyCollection);
                }

                propertyCollection.AddItem(id, name);
            }

            StringBuilder stringBuilder = new StringBuilder();
            bool          firstProperty = true;

            foreach (PropertyCollection propertyCollection in propertyCollections)
            {
                if (firstProperty)
                {
                    firstProperty = false;
                }
                else
                {
                    stringBuilder.AppendLine().AppendLine();
                }

                stringBuilder
                .AppendFormat("        private KeyValuePair<int, {1}>[] m_{0} = null;", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                .AppendLine()
                .AppendFormat("        public int {0}Count", propertyCollection.Name).AppendLine()
                .AppendLine("        {")
                .AppendLine("            get")
                .AppendLine("            {")
                .AppendFormat("                return m_{0}.Length;", propertyCollection.Name).AppendLine()
                .AppendLine("            }")
                .AppendLine("        }")
                .AppendLine()
                .AppendFormat("        public {1} Get{0}(int id)", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                .AppendLine("        {")
                .AppendFormat("            foreach (KeyValuePair<int, {1}> i in m_{0})", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                .AppendLine("            {")
                .AppendLine("                if (i.Key == id)")
                .AppendLine("                {")
                .AppendLine("                    return i.Value;")
                .AppendLine("                }")
                .AppendLine("            }")
                .AppendLine()
                .AppendFormat("            throw new GameFrameworkException(Utility.Text.Format(\"Get{0} with invalid id '{{0}}'.\", id.ToString()));", propertyCollection.Name).AppendLine()
                .AppendLine("        }")
                .AppendLine()
                .AppendFormat("        public {1} Get{0}At(int index)", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                .AppendLine("        {")
                .AppendFormat("            if (index < 0 || index >= m_{0}.Length)", propertyCollection.Name).AppendLine()
                .AppendLine("            {")
                .AppendFormat("                throw new GameFrameworkException(Utility.Text.Format(\"Get{0}At with invalid index '{{0}}'.\", index.ToString()));", propertyCollection.Name).AppendLine()
                .AppendLine("            }")
                .AppendLine()
                .AppendFormat("            return m_{0}[index].Value;", propertyCollection.Name).AppendLine()
                .Append("        }");
            }

            if (propertyCollections.Count > 0)
            {
                stringBuilder.AppendLine().AppendLine();
            }

            stringBuilder
            .AppendLine("        private void GeneratePropertyArray()")
            .AppendLine("        {");

            firstProperty = true;
            foreach (PropertyCollection propertyCollection in propertyCollections)
            {
                if (firstProperty)
                {
                    firstProperty = false;
                }
                else
                {
                    stringBuilder.AppendLine().AppendLine();
                }

                stringBuilder
                .AppendFormat("            m_{0} = new KeyValuePair<int, {1}>[]", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                .AppendLine("            {");

                int itemCount = propertyCollection.ItemCount;
                for (int i = 0; i < itemCount; i++)
                {
                    KeyValuePair <int, string> item = propertyCollection.GetItem(i);
                    stringBuilder.AppendFormat("                new KeyValuePair<int, {0}>({1}, {2}),", propertyCollection.LanguageKeyword, item.Key.ToString(), item.Value).AppendLine();
                }

                stringBuilder.Append("            };");
            }

            stringBuilder
            .AppendLine()
            .Append("        }");

            return(stringBuilder.ToString());
        }
예제 #42
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CompilerContext"/> class.
 /// </summary>
 public CompilerContext()
 {
     Properties = new PropertyCollection();
 }
예제 #43
0
 public UserInfoRecordDescription(UserInfoRecordDescription description)
 {
     Channel    = description.Channel;
     Properties = new PropertyCollection <object>(description.Properties ?? new PropertyCollection <object>(0));
 }
예제 #44
0
        public TilePropertiesCommand(Tile tile, string newId, BlendMode newBlendMode, PropertyCollection newProperties)
        {
            m_tile = tile;

            m_oldId         = tile.Id;
            m_oldBlendMode  = tile.BlendMode;
            m_oldProperties = new PropertyCollection(tile.Properties);

            m_newId         = newId;
            m_newBlendMode  = newBlendMode;
            m_newProperties = newProperties;

            m_description = "Change tile properties";
        }
예제 #45
0
        public static PropertyCollection getDefaultStructValue(string className, bool stripTransients)
        {
            bool isImmutable = UnrealObjectInfo.IsImmutable(className, MEGame.ME2);

            if (Structs.ContainsKey(className))
            {
                ClassInfo info = Structs[className];
                try
                {
                    PropertyCollection structProps = new PropertyCollection();
                    ClassInfo          tempInfo    = info;
                    while (tempInfo != null)
                    {
                        foreach ((string propName, PropertyInfo propInfo) in tempInfo.properties)
                        {
                            if (stripTransients && propInfo.Transient)
                            {
                                continue;
                            }
                            if (getDefaultProperty(propName, propInfo, stripTransients, isImmutable) is Property uProp)
                            {
                                structProps.Add(uProp);
                            }
                        }
                        if (!Structs.TryGetValue(tempInfo.baseClass, out tempInfo))
                        {
                            tempInfo = null;
                        }
                    }
                    structProps.Add(new NoneProperty());

                    string filepath = null;
                    if (ME2Directory.BioGamePath != null)
                    {
                        filepath = Path.Combine(ME2Directory.BioGamePath, info.pccPath);
                    }

                    Stream loadStream = null;
                    if (File.Exists(info.pccPath))
                    {
                        filepath   = info.pccPath;
                        loadStream = new MemoryStream(File.ReadAllBytes(info.pccPath));
                    }
                    else if (info.pccPath == UnrealObjectInfo.Me3ExplorerCustomNativeAdditionsName)
                    {
                        filepath   = "GAMERESOURCES_ME2";
                        loadStream = Utilities.LoadFileFromCompressedResource("GameResources.zip", CoreLib.CustomResourceFileName(MEGame.ME2));
                    }
                    else if (filepath != null && File.Exists(filepath))
                    {
                        loadStream = new MemoryStream(File.ReadAllBytes(filepath));
                    }
#if AZURE
                    else if (MiniGameFilesPath != null && File.Exists(Path.Combine(MiniGameFilesPath, info.pccPath)))
                    {
                        // Load from test minigame folder. This is only really useful on azure where we don't have access to
                        // games
                        filepath   = Path.Combine(MiniGameFilesPath, info.pccPath);
                        loadStream = new MemoryStream(File.ReadAllBytes(filepath));
                    }
#endif

                    if (loadStream != null)
                    {
                        using (IMEPackage importPCC = MEPackageHandler.OpenMEPackageFromStream(loadStream, filepath, useSharedPackageCache: true))
                        {
                            var                exportToRead = importPCC.GetUExport(info.exportIndex);
                            byte[]             buff         = exportToRead.Data.Skip(0x30).ToArray();
                            PropertyCollection defaults     = PropertyCollection.ReadProps(exportToRead, new MemoryStream(buff), className);
                            foreach (var prop in defaults)
                            {
                                structProps.TryReplaceProp(prop);
                            }
                        }
                    }
                    return(structProps);
                }
                catch
                {
                    return(null);
                }
            }
            return(null);
        }
예제 #46
0
 public void SetProperties(PropertyCollection properties)
 {
     _properties = properties;
 }
예제 #47
0
        static void Main(string[] args)
        {
            for (int i = 0; i < args.Length; i++)
            {
                switch (args[i])
                {
                case "/proc":
                    if (i + 1 == args.Length)
                    {
                        Console.WriteLine("Use /proc <N> to specify number of processors");
                        return;
                    }

                    int numProcs;

                    if (Int32.TryParse(args[i + 1], out numProcs))
                    {
                        // only increment i if successful b/c we're going to continue the run
                        // with the default # of processors and don't want to automatically
                        // eat the next parameter.
                        ++i;
                        Processor.LogicalCpuCount = numProcs;
                    }
                    else
                    {
                        Console.WriteLine("You must specify a integer for /proc <N>, continuing with default");
                    }
                    break;

                case "/image":
                    if (i + 1 == args.Length)
                    {
                        Console.WriteLine("Use /image <filename> to specify a file to perform benchmark with");
                        return;
                    }

                    ++i;
                    benchmarkImageName = args[i];

                    if (!File.Exists(benchmarkImageName))
                    {
                        Console.WriteLine("Specified image doesn't exist");
                        return;
                    }
                    break;

                case "/tsv":
                    useTsvOutput = true;
                    break;

                case "/?":
                    PrintHelp();
                    return;

                default:
                    break;
                }
            }

            //Processor.LogicalCpuCount = 1;
            Console.WriteLine("PdnBench v" + PdnInfo.GetVersion());
            Console.WriteLine("Running in " + (8 * Marshal.SizeOf(typeof(IntPtr))) + "-bit mode on Windows " +
                              Environment.OSVersion.Version.ToString() + " " +
                              OS.Revision + (OS.Revision.Length > 0 ? " " : string.Empty) +
                              OS.Type + " " +
                              Processor.NativeArchitecture.ToString().ToLower());

            Console.WriteLine("Processor: " + Processor.LogicalCpuCount + "x \"" + Processor.CpuName + "\" @ ~" + GetCpuSpeed() + " MHz");
            Console.WriteLine("Memory: " + ((Memory.TotalPhysicalBytes / 1024) / 1024) + " MB");
            Console.WriteLine();

            Console.WriteLine("Using " + Processor.LogicalCpuCount + " threads.");

            ArrayList benchmarks = new ArrayList();

            Document document;

            Console.Write("Loading image ... ");

            Stream imageStream = null;

            try
            {
                imageStream = (defaultImageName == benchmarkImageName) ?
                              Assembly.GetExecutingAssembly().GetManifestResourceStream(benchmarkImageName) :
                              new FileStream(benchmarkImageName, FileMode.Open);

                JpegFileType jft = new JpegFileType();
                document = jft.Load(imageStream);
            }

            finally
            {
                if (imageStream != null)
                {
                    imageStream.Dispose();
                }
            }

            Console.WriteLine("(" + document.Width + " x " + document.Height + ") done");

            Surface surface = ((BitmapLayer)document.Layers[0]).Surface;

            Surface dst = new Surface(surface.Width * 4, surface.Height * 4);

#if EFFECTS
            for (double i = 0; i < (2 * Math.PI); i += 70.0 * ((2 * Math.PI) / 360.0))
            {
                benchmarks.Add(
                    new EffectBenchmark("Rotate/Zoom at " + ((i * 180.0) / Math.PI).ToString("F2") + " degrees",
                                        3,
                                        new RotateZoomEffect(),
                                        new RotateZoomEffectConfigToken(
                                            true,
                                            (float)(Math.PI * 0.3f),
                                            (float)((Math.PI * -0.4) + i),
                                            50,
                                            0.5f,
                                            new PointF(-0.2f, 0.3f),
                                            false,
                                            true),
                                        surface));
            }

            for (int i = 1; i <= 4; i += 3)
            {
                for (int j = 10; j < 100; j += 75)
                {
                    OilPaintingEffect  e     = new OilPaintingEffect();
                    PropertyCollection props = e.CreatePropertyCollection();
                    props[OilPaintingEffect.PropertyNames.BrushSize].Value  = i;
                    props[OilPaintingEffect.PropertyNames.Coarseness].Value = j;

                    benchmarks.Add(
                        new EffectBenchmark(
                            "Oil Painting, brush size = " + i + ", coarseness = " + j,
                            1,
                            e,
                            new PropertyBasedEffectConfigToken(props),
                            surface));
                }
            }

            for (int i = 2; i <= 200; i += i)
            {
                GaussianBlurEffect e     = new GaussianBlurEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props[GaussianBlurEffect.PropertyNames.Radius].Value = i;

                benchmarks.Add(
                    new EffectBenchmark(
                        "Gaussian Blur with radius of " + i,
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            for (int i = 1; i <= 4; i += 3)
            {
                SharpenEffect      e     = new SharpenEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props[SharpenEffect.PropertyNames.Amount].Value = i;

                benchmarks.Add(
                    new EffectBenchmark(
                        "Sharpen with value of " + i,
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            for (int i = 81; i >= 5; i /= 3)
            {
                CloudsEffect       e     = new CloudsEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props["Scale"].Value   = 50;
                props["Power"].Value   = (double)i / 100.0;
                props["Seed"].Value    = 12345 % 255;
                props["BlendOp"].Value = typeof(UserBlendOps.NormalBlendOp);

                benchmarks.Add(
                    new EffectBenchmark(
                        "Clouds, roughness = " + i,
                        2,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            for (int i = 4; i <= 64; i *= 4)
            {
                MedianEffect       e     = new MedianEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props[MedianEffect.PropertyNames.Radius].Value     = i;
                props[MedianEffect.PropertyNames.Percentile].Value = 50;

                benchmarks.Add(
                    new EffectBenchmark(
                        "Median, radius " + i,
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            for (int i = 4; i <= 64; i *= 4)
            {
                UnfocusEffect      e     = new UnfocusEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props[UnfocusEffect.PropertyNames.Radius].Value = i;

                benchmarks.Add(
                    new EffectBenchmark(
                        "Unfocus, radius " + i,
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            {
                MotionBlurEffect   e     = new MotionBlurEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props[MotionBlurEffect.PropertyNames.Angle].Value    = 0.0;
                props[MotionBlurEffect.PropertyNames.Distance].Value = 15;
                props[MotionBlurEffect.PropertyNames.Centered].Value = true;

                benchmarks.Add(
                    new EffectBenchmark(
                        "Motion Blur, Horizontal",
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            {
                MotionBlurEffect   e     = new MotionBlurEffect();
                PropertyCollection props = e.CreatePropertyCollection();
                props[MotionBlurEffect.PropertyNames.Angle].Value    = 90.0;
                props[MotionBlurEffect.PropertyNames.Distance].Value = 15;
                props[MotionBlurEffect.PropertyNames.Centered].Value = true;

                benchmarks.Add(
                    new EffectBenchmark(
                        "Motion Blur, Vertical",
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            {
                ReduceNoiseEffect  e     = new ReduceNoiseEffect();
                PropertyCollection props = e.CreatePropertyCollection();

                benchmarks.Add(
                    new EffectBenchmark(
                        "Reduce Noise (3x)",
                        3,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        dst));
            }

            {
                MandelbrotFractalEffect e     = new MandelbrotFractalEffect();
                PropertyCollection      props = e.CreatePropertyCollection();

                benchmarks.Add(
                    new EffectBenchmark(
                        "Mandelbrot Fractal",
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }

            {
                JuliaFractalEffect e     = new JuliaFractalEffect();
                PropertyCollection props = e.CreatePropertyCollection();

                benchmarks.Add(
                    new EffectBenchmark(
                        "Julia Fractal",
                        1,
                        e,
                        new PropertyBasedEffectConfigToken(props),
                        surface));
            }
#endif

#if RESIZE
            // Resize benchmarks
            for (int i = 1; i < 8; i += 2)
            {
                int newWidth  = i * (dst.Width / 8);
                int newHeight = i * (dst.Height / 8);

                Surface dstWindow = dst.CreateWindow(new Rectangle(0, 0, newWidth, newHeight));
                benchmarks.Add(new ResizeBenchmark("Resize from " + surface.Width + "x" + surface.Height + " to " + newWidth + "x" + newHeight, surface, dstWindow));
                benchmarks.Add(new ResizeBenchmark("Resize from " + newWidth + "x" + newHeight + " to " + surface.Width + "x" + surface.Height, dstWindow, surface));
            }
#endif

#if GRADIENT
            // Gradient benchmarks
            benchmarks.Add(new GradientBenchmark(
                               "Linear reflected gradient @ " + dst.Width + "x" + dst.Height + " (5x)",
                               dst,
                               new GradientRenderers.LinearReflected(false, new UserBlendOps.NormalBlendOp()),
                               2));

            benchmarks.Add(new GradientBenchmark(
                               "Conical gradient @ " + dst.Width + "x" + dst.Height + " (5x)",
                               dst,
                               new GradientRenderers.Conical(false, new UserBlendOps.NormalBlendOp()),
                               2));

            benchmarks.Add(new GradientBenchmark(
                               "Radial gradient @ " + dst.Width + "x" + dst.Height + " (5x)",
                               dst,
                               new GradientRenderers.Radial(false, new UserBlendOps.NormalBlendOp()),
                               2));
#endif

#if COMPOSITION
            // Composition benchmarks
            Document    doc1   = new Document(surface.Size);
            BitmapLayer layer1 = Layer.CreateBackgroundLayer(doc1.Width, doc1.Height);
            layer1.Surface.CopySurface(surface);
            doc1.Layers.Add(layer1);
            doc1.Layers.Add(layer1.Clone());
            doc1.Layers.Add(layer1.Clone());
            doc1.Layers.Add(layer1.Clone());

            benchmarks.Add(new CompositionBenchmark("Compositing one layer, Normal blend mode, 255 opacity (" + CompositionBenchmark.Iterations + "x)",
                                                    doc1,
                                                    surface,
                                                    delegate(int layerIndex, Layer layer)
            {
                if (layerIndex == 0)
                {
                    layer.Visible = true;
                    layer.Opacity = 255;
                    ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.NormalBlendOp());
                }
                else
                {
                    layer.Visible = false;
                }
            }));

            benchmarks.Add(new CompositionBenchmark("Compositing one layer, Normal blend mode, 128 opacity (" + CompositionBenchmark.Iterations + "x)",
                                                    doc1,
                                                    surface,
                                                    delegate(int layerIndex, Layer layer)
            {
                if (layerIndex == 0)
                {
                    layer.Visible = true;
                    layer.Opacity = 128;
                    ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.NormalBlendOp());
                }
                else
                {
                    layer.Visible = false;
                }
            }));

            benchmarks.Add(new CompositionBenchmark("Compositing four layers, Normal blend mode, 255 opacity (" + CompositionBenchmark.Iterations + "x)",
                                                    doc1,
                                                    surface,
                                                    delegate(int layerIndex, Layer layer)
            {
                layer.Visible = true;
                layer.Opacity = 255;
                ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.NormalBlendOp());
            }));

            benchmarks.Add(new CompositionBenchmark("Compositing four layers, Normal blend mode, 255 (layer 0) and 128 (layer 1-3) opacity (" + CompositionBenchmark.Iterations + "x)", doc1, surface,
                                                    delegate(int layerIndex, Layer layer)
            {
                layer.Visible = true;
                layer.Opacity = 128;
                ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.NormalBlendOp());
            }));

            benchmarks.Add(new CompositionBenchmark("Compositing four layers, Normal blend mode, 128 opacity (" + CompositionBenchmark.Iterations + "x)", doc1, surface,
                                                    delegate(int layerIndex, Layer layer)
            {
                layer.Visible = true;
                layer.Opacity = 128;
                ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.NormalBlendOp());
            }));

            benchmarks.Add(new CompositionBenchmark("Compositing three layers, Normal+Multiply+Overlay blending, 150+255+170 opacity (" + CompositionBenchmark.Iterations + "x)", doc1, surface,
                                                    delegate(int layerIndex, Layer layer)
            {
                if (layerIndex == 0)
                {
                    layer.Visible = true;
                    layer.Opacity = 150;
                    ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.NormalBlendOp());
                }
                else if (layerIndex == 1)
                {
                    layer.Visible = true;
                    layer.Opacity = 255;
                    ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.MultiplyBlendOp());
                }
                else if (layerIndex == 2)
                {
                    layer.Visible = true;
                    layer.Opacity = 170;
                    ((BitmapLayer)layer).SetBlendOp(new UserBlendOps.OverlayBlendOp());
                }
                else
                {
                    layer.Visible = false;
                }
            }));
#endif

#if TRANSFORM
            // Transform benchmarks
            Matrix m = new Matrix();
            m.Reset();

            MaskedSurface msSimple = new MaskedSurface(surface, new PdnRegion(surface.Bounds)); // simple masked surface

            PdnRegion complexRegion = new PdnRegion(surface.Bounds);

            // cut 4 holes in region 1 to form a complex clipping surface
            for (int x = -1; x < 3; ++x)
            {
                for (int y = -1; y < 3; ++y)
                {
                    int left   = (1 + (x * 3)) * (surface.Width / 6);
                    int top    = (1 + (x * 3)) * (surface.Height / 6);
                    int right  = (2 + (x * 3)) * (surface.Width / 6);
                    int bottom = (2 + (x * 3)) * (surface.Height / 6);

                    Rectangle       rect = Rectangle.FromLTRB(left, top, right, bottom);
                    PdnGraphicsPath path = new PdnGraphicsPath();
                    path.AddEllipse(rect);
                    complexRegion.Exclude(path);
                }
            }

            MaskedSurface msComplex = new MaskedSurface(surface, complexRegion);

            benchmarks.Add(new TransformBenchmark("Transform simple surface, no transform, nearest neighbor resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m,
                                                  false));

            benchmarks.Add(new TransformBenchmark("Transform complex surface, no transform, nearest neighbor resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m,
                                                  false));

            benchmarks.Add(new TransformBenchmark("Transform simple surface, no transform, bilinear resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m,
                                                  true));

            benchmarks.Add(new TransformBenchmark("Transform complex surface, no transform, bilinear resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m,
                                                  true));

            Matrix m2 = m.Clone();
            m2.RotateAt(45.0f, new PointF(surface.Width / 2, surface.Height / 2));

            benchmarks.Add(new TransformBenchmark("Transform simple surface, 45 deg. rotation about center, bilinear resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m2,
                                                  true));

            benchmarks.Add(new TransformBenchmark("Transform complex surface, 45 deg. rotation about center, bilinear resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m2,
                                                  true));

            Matrix m3 = m.Clone();
            m3.Scale(0.5f, 0.75f);

            benchmarks.Add(new TransformBenchmark("Transform simple surface, 50% x-scaling 75% y-scaling, bilinear resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m3,
                                                  true));

            benchmarks.Add(new TransformBenchmark("Transform complex surface, 50% x-scaling 75% y-scaling, bilinear resampling (" + TransformBenchmark.Iterations + "x)",
                                                  surface,
                                                  msSimple,
                                                  m3,
                                                  true));
#endif

#if BLIT
            // Blit benchmarks
            benchmarks.Add(new ZoomOutBlitBenchmark("Zoom out, rotated grid multisampling, 66% (" + ZoomOutBlitBenchmark.IterationCount + "x)",
                                                    surface,
                                                    dst,
                                                    new Size((surface.Width * 2) / 3, (surface.Height * 2) / 3)));

            benchmarks.Add(new ZoomOutBlitBenchmark("Zoom out, rotated grid multisampling, 28% (" + ZoomOutBlitBenchmark.IterationCount + "x)",
                                                    surface,
                                                    dst,
                                                    new Size((surface.Width * 28) / 100, (surface.Height * 28) / 100)));

            benchmarks.Add(new ZoomOneToOneBlitBenchmark("Zoom 1:1, straight blit (" + ZoomOneToOneBlitBenchmark.IterationCount + "x)",
                                                         surface,
                                                         dst.CreateWindow(new Rectangle(0, 0, surface.Width, surface.Height))));
#endif

            // Run benchmarks!
            Timing timing = new Timing();
            ulong  start  = timing.GetTickCount();

            foreach (Benchmark benchmark in benchmarks)
            {
                Console.Write(benchmark.Name + (useTsvOutput ? "\t" : " ... "));
                TimeSpan timeSpan = benchmark.Execute();
                Console.WriteLine(" " + timeSpan.TotalMilliseconds.ToString() + (useTsvOutput ? "\t" : "") + " milliseconds");

                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
                GC.WaitForPendingFinalizers();
            }

            ulong end = timing.GetTickCount();

            Console.WriteLine();
            Console.WriteLine("Total time: " + (useTsvOutput ? "\t" : "") + (end - start).ToString() + (useTsvOutput ? "\t" : "") + " milliseconds");
            Console.WriteLine();
        }
예제 #48
0
 protected virtual ControlInfo OnCreateConfigUI(PropertyCollection props)
 {
     return(CreateDefaultConfigUI(props));
 }
예제 #49
0
파일: Field.cs 프로젝트: rjankovic/deskmin
 public M2NMappingField(int fieldId, string column, int typeId, string typeName, int panelId, IM2NMapping mapping,
                        PropertyCollection attr = null, PropertyCollection rules = null)
     : base(fieldId, column, typeId, typeName, panelId, attr, rules)
 {
     this.mapping = mapping;
 }
예제 #50
0
        void SetLabel()
        {
            ManagementPath mgmtPath = mgmtObj.Path;

            if (mgmtPath.IsSingleton)
            {
                label = mgmtPath.ClassName;
            }
            else
            {
                //this is not a singleton.  Construct label to consist of comma-separated
                //key property values and caption value.
                bool   needCaption = true;
                string keyVals     = string.Empty;
                string caption     = string.Empty;

                PropertyCollection props = mgmtObj.Properties;
                try
                {
                    caption = props["Caption"].Value.ToString();
                }
                catch (Exception)
                {
                    //no "Caption" property
                    needCaption = false;
                }

                if (caption == string.Empty)
                {
                    needCaption = false;
                }

                //get key property values
                PropertyCollection.PropertyEnumerator propEnum = mgmtObj.Properties.GetEnumerator();

                while (propEnum.MoveNext())
                {
                    if (WmiHelper.IsKeyProperty(propEnum.Current))
                    {
                        string keyval = propEnum.Current.Value.ToString();
                        if (needCaption && (string.Compare(keyval, caption, true) == 0))
                        {
                            needCaption = false;
                        }
                        keyVals += keyval + ",";
                    }
                }


                if (keyVals != string.Empty)
                {
                    //get rid of last character (a comma)
                    keyVals = keyVals.Substring(0, keyVals.Length - 1);
                }

                if (needCaption)
                {
                    label = caption + "(" + keyVals + ")";
                }
                else
                {
                    label = keyVals;
                }

                if (label == string.Empty)
                {
                    label = className;
                }
            }
        }
예제 #51
0
        public static void CreateReachSpec(ExportEntry startNode, bool createTwoWay, ExportEntry destinationNode, string reachSpecClass, ReachSpecSize size, PropertyCollection externalGUIDProperties = null)
        {
            IMEPackage  Pcc = startNode.FileRef;
            ExportEntry reachSpectoClone = Pcc.Exports.FirstOrDefault(x => x.ClassName == "ReachSpec");

            if (externalGUIDProperties != null) //EXTERNAL
            {
                //external node

                //Debug.WriteLine("Num Exports: " + pcc.Exports.Count);
                if (reachSpectoClone != null)
                {
                    ExportEntry outgoingSpec = reachSpectoClone.Clone();
                    Pcc.AddExport(outgoingSpec);

                    IEntry reachSpecClassImp = GetEntryOrAddImport(Pcc, reachSpecClass); //new class type.

                    outgoingSpec.Class      = reachSpecClassImp;
                    outgoingSpec.ObjectName = reachSpecClassImp.ObjectName;

                    var            properties            = outgoingSpec.GetProperties();
                    ObjectProperty outgoingSpecStartProp = properties.GetProp <ObjectProperty>("Start");                                                                   //START
                    StructProperty outgoingEndStructProp = properties.GetProp <StructProperty>("End");                                                                     //Embeds END
                    ObjectProperty outgoingSpecEndProp   = outgoingEndStructProp.Properties.GetProp <ObjectProperty>(SharedPathfinding.GetReachSpecEndName(outgoingSpec)); //END
                    outgoingSpecStartProp.Value = startNode.UIndex;
                    outgoingSpecEndProp.Value   = 0;
                    var endGuid = outgoingEndStructProp.GetProp <StructProperty>("Guid");
                    endGuid.Properties = externalGUIDProperties; //set the other guid values to our guid values

                    //Add to source node prop
                    ArrayProperty <ObjectProperty> PathList = startNode.GetProperty <ArrayProperty <ObjectProperty> >("PathList");
                    PathList.Add(new ObjectProperty(outgoingSpec.UIndex));
                    startNode.WriteProperty(PathList);
                    outgoingSpec.WriteProperties(properties);


                    //Write Spec Size
                    SharedPathfinding.SetReachSpecSize(outgoingSpec, size.SpecRadius, size.SpecHeight);

                    //Reindex reachspecs.
                    SharedPathfinding.ReindexMatchingObjects(outgoingSpec);
                }
            }
            else
            {
                //Debug.WriteLine("Source Node: " + startNode.Index);

                //Debug.WriteLine("Num Exports: " + pcc.Exports.Count);
                //int outgoingSpec = pcc.ExportCount;
                //int incomingSpec = pcc.ExportCount + 1;


                if (reachSpectoClone != null)
                {
                    ExportEntry outgoingSpec = reachSpectoClone.Clone();
                    Pcc.AddExport(outgoingSpec);
                    ExportEntry incomingSpec = null;
                    if (createTwoWay)
                    {
                        incomingSpec = reachSpectoClone.Clone();
                        Pcc.AddExport(incomingSpec);
                    }

                    IEntry reachSpecClassImp = GetEntryOrAddImport(Pcc, reachSpecClass); //new class type.

                    outgoingSpec.Class      = reachSpecClassImp;
                    outgoingSpec.ObjectName = reachSpecClassImp.ObjectName;

                    var outgoingSpecProperties = outgoingSpec.GetProperties();
                    if (reachSpecClass == "Engine.SlotToSlotReachSpec")
                    {
                        outgoingSpecProperties.Add(new ByteProperty(1, "SpecDirection")); //We might need to find a way to support this edit
                    }

                    //Debug.WriteLine("Outgoing UIndex: " + outgoingSpecExp.UIndex);

                    ObjectProperty outgoingSpecStartProp = outgoingSpecProperties.GetProp <ObjectProperty>("Start");                                                       //START
                    StructProperty outgoingEndStructProp = outgoingSpecProperties.GetProp <StructProperty>("End");                                                         //Embeds END
                    ObjectProperty outgoingSpecEndProp   = outgoingEndStructProp.Properties.GetProp <ObjectProperty>(SharedPathfinding.GetReachSpecEndName(outgoingSpec)); //END
                    outgoingSpecStartProp.Value = startNode.UIndex;
                    outgoingSpecEndProp.Value   = destinationNode.UIndex;

                    //Add to source node prop
                    var PathList = startNode.GetProperty <ArrayProperty <ObjectProperty> >("PathList");
                    PathList.Add(new ObjectProperty(outgoingSpec.UIndex));
                    startNode.WriteProperty(PathList);

                    //Write Spec Size
                    SetReachSpecSize(outgoingSpecProperties, size.SpecRadius, size.SpecHeight);
                    outgoingSpec.WriteProperties(outgoingSpecProperties);

                    if (createTwoWay)
                    {
                        incomingSpec.Class      = reachSpecClassImp;
                        incomingSpec.ObjectName = reachSpecClassImp.ObjectName;
                        var incomingSpecProperties = incomingSpec.GetProperties();
                        if (reachSpecClass == "Engine.SlotToSlotReachSpec")
                        {
                            incomingSpecProperties.Add(new ByteProperty(2, "SpecDirection"));
                        }

                        ObjectProperty incomingSpecStartProp = incomingSpecProperties.GetProp <ObjectProperty>("Start");                                                       //START
                        StructProperty incomingEndStructProp = incomingSpecProperties.GetProp <StructProperty>("End");                                                         //Embeds END
                        ObjectProperty incomingSpecEndProp   = incomingEndStructProp.Properties.GetProp <ObjectProperty>(SharedPathfinding.GetReachSpecEndName(incomingSpec)); //END

                        incomingSpecStartProp.Value = destinationNode.UIndex;                                                                                                  //Uindex
                        incomingSpecEndProp.Value   = startNode.UIndex;


                        //Add reachspec to destination node's path list (returning)
                        var DestPathList = destinationNode.GetProperty <ArrayProperty <ObjectProperty> >("PathList");
                        DestPathList.Add(new ObjectProperty(incomingSpec.UIndex));
                        destinationNode.WriteProperty(DestPathList);

                        //destNode.WriteProperty(DestPathList);
                        SetReachSpecSize(incomingSpecProperties, size.SpecRadius, size.SpecHeight);

                        incomingSpec.WriteProperties(incomingSpecProperties);
                    }

                    //Reindex reachspecs.
                    SharedPathfinding.ReindexMatchingObjects(outgoingSpec);
                }
            }
        }
예제 #52
0
 protected virtual void OnCustomizeConfigUIWindowProperties(PropertyCollection props)
 {
     return;
 }
예제 #53
0
 private static void AddPropertyTextAlignment(PropertyCollection properties, string propertyParent,
                                              string propertyName, string propertyCaption)
 {
     AddProperty <PropertyEditorTextAlignment>(properties, propertyParent, propertyName, propertyCaption);
 }
예제 #54
0
        // Редакторы сложных свойств элементов печатного представления

        private static void AddPropertyDisplayFormat(PropertyCollection properties, string propertyParent,
                                                     string propertyName, string propertyCaption)
        {
            AddProperty <PropertyEditorDisplayFormat>(properties, propertyParent, propertyName, propertyCaption);
        }
예제 #55
0
 private static void AddPropertyThickness(PropertyCollection properties, string propertyParent,
                                          string propertyName, string propertyCaption)
 {
     AddProperty <PropertyEditorThickness>(properties, propertyParent, propertyName, propertyCaption);
 }
예제 #56
0
 private static void AddPropertyColor(PropertyCollection properties, string propertyParent, string propertyName,
                                      string propertyCaption)
 {
     AddProperty <PropertyEditorColor>(properties, propertyParent, propertyName, propertyCaption);
 }
예제 #57
0
 public CountedTaggerTest()
 {
     _factory            = new MockRepository(MockBehavior.Strict);
     _key                = new object();
     _propertyCollection = new PropertyCollection();
 }
예제 #58
0
 private CountedTagger <TextMarkerTag> Create(object key, PropertyCollection propertyCollection, Func <ITagger <TextMarkerTag> > func)
 {
     return(new CountedTagger <TextMarkerTag>(propertyCollection, key, func));
 }
예제 #59
0
        public void Refresh()
        {
            if (Instance == null)
            {
                Properties = new ObservableCollection <Item>();
            }
            else
            {
                var properties = new PropertyCollection(Instance, !Categorized, AutomaticlyExpandObjects,
                                                        Filter.ToLower());
                Properties = properties.Items;

                if (Instance != null)
                {
                    /// Fill the Instance type and Name with the Data
                    if (Template != null)
                    {
                        object myInstanceType = Template.FindName("PART_InstanceType", this);

                        if (myInstanceType != null && myInstanceType is TextBlock)
                        {
                            string   myType       = "";
                            Object[] myAttributes = Instance.GetType().GetCustomAttributes(false);
                            if (myAttributes.Length > 0)
                            {
                                foreach (Object attr in myAttributes)
                                {
                                    if (attr is System.ComponentModel.DisplayNameAttribute)
                                    {
                                        myType = ((System.ComponentModel.DisplayNameAttribute)attr).DisplayName;
                                    }
                                }
                            }
                            if (myType.Length == 0)
                            {
                                myType = Instance.GetType().ToString();
                                myType = myType.Substring(myType.LastIndexOf('.') + 1);
                            }
                            if (myType.Equals("componentType"))
                            {
                                myType = Asterics.ACS.Properties.Resources.PropertyEditorModelComponentAlias;
                            }
                            else if (myType.Equals("inputPortType"))
                            {
                                myType = Asterics.ACS.Properties.Resources.PropertyEditorInputPortTypeAlias;
                            }
                            else if (myType.Equals("outputPortType"))
                            {
                                myType = Asterics.ACS.Properties.Resources.PropertyEditorOutputPortTypeAlias;
                            }
                            ((TextBlock)myInstanceType).Text = myType;
                        }


                        object myInstanceName = Template.FindName("PART_InstanceName", this);

                        if (myInstanceName != null && myInstanceName is TextBlock)
                        {
                            if (Instance is FrameworkElement)
                            {
                                ((TextBlock)myInstanceName).Text = ((FrameworkElement)Instance).Name;
                            }
                            else if (Instance is System.Windows.Forms.Control)
                            {
                                ((TextBlock)myInstanceName).Text = ((System.Windows.Forms.Control)Instance).Name;
                            }
                            else if (DisplayName != "")
                            {
                                ((TextBlock)myInstanceName).Text = DisplayName; // new code for AsTeRICS
                            }
                            else
                            {
                                ((TextBlock)myInstanceName).Text = "";
                                PropertyInfo pi = Instance.GetType().GetProperty("Name");
                                if (pi != null)
                                {
                                    ((TextBlock)myInstanceName).Text = (string)pi.GetValue(Instance, null);
                                }
                            }
                        }
                    }
                }
            }
        }
예제 #60
0
        /*
         * private static void VerifyGesturesWork(ExportEntry trackExport)
         * {
         *  var gestures = RBioEvtSysTrackGesture.GetGestures(trackExport);
         *  var defaultPose = RBioEvtSysTrackGesture.GetDefaultPose(trackExport);
         *
         *  var gesturesToCheck = gestures.Append(defaultPose).ToList();
         *
         *  // Get the containing sequence
         *  var owningSequence = SeqTools.GetParentSequence(trackExport);
         *  while (owningSequence.ClassName != "Sequence")
         *  {
         *      owningSequence = owningSequence.Parent as ExportEntry;
         *      var parSeq = SeqTools.GetParentSequence(owningSequence);
         *      if (parSeq != null)
         *      {
         *          owningSequence = parSeq;
         *      }
         *  }
         *
         *  var kismetBioDynamicAnimSets = owningSequence.GetProperty<ArrayProperty<ObjectProperty>>("m_aBioDynAnimSets");
         *  if (kismetBioDynamicAnimSets == null)
         *  {
         *      // We don't have any animsets!
         *      throw new Exception("Track's sequence is missing animsets property!");
         *  }
         *
         *  // Get a list of all supported animations
         *  List<Gesture> supportedGestures = new List<Gesture>();
         *  foreach (var kbdas in kismetBioDynamicAnimSets)
         *  {
         *      var sequenceBioDynamicAnimSet = kbdas.ResolveToEntry(trackExport.FileRef) as ExportEntry; // I don't think these can be imports as they're part of the seq
         *      var associatedset = sequenceBioDynamicAnimSet.GetProperty<ObjectProperty>("m_pBioAnimSetData").ResolveToEntry(trackExport.FileRef);
         *
         *  }
         *
         *  // Check all gestures
         *  foreach (var gesture in gesturesToCheck)
         *  {
         *      var bioAnimSet = gesture.GetBioAnimSet(trackExport.FileRef);
         *
         *  }
         *
         *
         *
         * }
         *
         * internal class TestingBioDynamicAnimSet
         * {
         *  public NameReference OrigSetName { get; }
         *  public List<string> SupportedGesturesFullPaths { get; }
         *  public IEntry BioAnimSetData { get; }
         *
         *  internal TestingBioDynamicAnimSet(ExportEntry export)
         *  {
         *      var props = export.GetProperties();
         *      OrigSetName = props.GetProp<NameProperty>("m_nmOrigSetName").Value;
         *      BioAnimSetData = props.GetProp<ObjectProperty>("m_pBioAnimSetData").ResolveToEntry(export.FileRef);
         *      SupportedGesturesFullPaths = props.GetProp<ArrayProperty<ObjectProperty>>("Sequences").Select(x => x.ResolveToEntry(export.FileRef).InstancedFullPath).ToList();
         *  }
         * }
         */
        private static void InstallDynamicAnimSetRefForSeq(ref ExportEntry owningSequence, ExportEntry export, Gesture gesture)
        {
            // Find owning sequence
            if (owningSequence == null)
            {
                owningSequence = export;
            }
            while (owningSequence.ClassName != "Sequence")
            {
                owningSequence = owningSequence.Parent as ExportEntry;
                var parSeq = SeqTools.GetParentSequence(owningSequence);
                if (parSeq != null)
                {
                    owningSequence = parSeq;
                }
            }

            // We have parent sequence data
            var kismetBioDynamicAnimSets = owningSequence.GetProperty <ArrayProperty <ObjectProperty> >("m_aBioDynAnimSets")
                                           ?? new ArrayProperty <ObjectProperty>("m_aBioDynamicAnimSets");

            // Check to see if there is any item that uses our bioanimset
            var bioAnimSet = gesture.GetBioAnimSet(export.FileRef);

            if (bioAnimSet != null)
            {
                ExportEntry kismetBDAS = null;
                foreach (var kbdas in kismetBioDynamicAnimSets)
                {
                    var kEntry        = kbdas.ResolveToEntry(export.FileRef) as ExportEntry; // I don't think these can be imports as they're part of the seq
                    var associatedset = kEntry.GetProperty <ObjectProperty>("m_pBioAnimSetData").ResolveToEntry(export.FileRef);
                    if (associatedset == bioAnimSet)
                    {
                        // It's this one
                        kismetBDAS = kEntry;
                        break;
                    }
                }

                if (kismetBDAS == null)
                {
                    // We need to generate a new one
                    PropertyCollection props = new PropertyCollection();
                    props.Add(new NameProperty(gesture.GestureSet, "m_nmOrigSetName"));
                    props.Add(new ArrayProperty <ObjectProperty>("Sequences"));
                    props.Add(new ObjectProperty(bioAnimSet, "m_pBioAnimSetData"));
                    kismetBDAS            = ExportCreator.CreateExport(export.FileRef, $"KIS_DYN_{gesture.GestureSet}", "BioDynamicAnimSet", owningSequence);
                    kismetBDAS.indexValue = 0;

                    // Write a blank count of 0 - we will update this in subsequent call
                    // This must be here to ensure parser can read it
                    kismetBDAS.WritePropertiesAndBinary(props, new byte[4]);
                    kismetBioDynamicAnimSets.Add(new ObjectProperty(kismetBDAS)); // Add new export to sequence's list of biodynamicanimsets
                    owningSequence.WriteProperty(kismetBioDynamicAnimSets);
                }

                var currentObjs = kismetBDAS.GetProperty <ArrayProperty <ObjectProperty> >("Sequences");
                if (currentObjs.All(x => x.Value != gesture.Entry.UIndex))
                {
                    // We need to add our item to it
                    currentObjs.Add(new ObjectProperty(gesture.Entry));
                    var bin = ObjectBinary.From <BioDynamicAnimSet>(kismetBDAS);
                    bin.SequenceNamesToUnkMap[gesture.GestureAnim] = 1; // Not sure what the value should be, or if game actually reads this
                    // FIX IT IF WE EVER FIGURE IT OUT!
                    kismetBDAS.WriteProperty(currentObjs);
                    kismetBDAS.WriteBinary(bin);
                }
            }
        }