content
stringlengths 5
1.04M
| avg_line_length
float64 1.75
12.9k
| max_line_length
int64 2
244k
| alphanum_fraction
float64 0
0.98
| licenses
sequence | repository_name
stringlengths 7
92
| path
stringlengths 3
249
| size
int64 5
1.04M
| lang
stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Xunit;
namespace System.Text.Tests
{
public class UTF8EncodingGetMaxByteCount
{
[Theory]
[InlineData(0)]
[InlineData(1)]
[InlineData(10)]
[InlineData(int.MaxValue / 3 - 1)]
public void GetMaxByteCount(int charCount)
{
int expected = (charCount + 1) * 3;
Assert.Equal(expected, new UTF8Encoding(true, true).GetMaxByteCount(charCount));
Assert.Equal(expected, new UTF8Encoding(true, false).GetMaxByteCount(charCount));
Assert.Equal(expected, new UTF8Encoding(false, true).GetMaxByteCount(charCount));
Assert.Equal(expected, new UTF8Encoding(false, false).GetMaxByteCount(charCount));
}
}
}
| 35.961538 | 94 | 0.660963 | [
"MIT"
] | 06needhamt/runtime | src/libraries/System.Text.Encoding/tests/UTF8Encoding/UTF8EncodingGetMaxByteCount.cs | 935 | C# |
// =================================================================================================
//
// Hammerc Library
// Copyright 2015 hammerc.org All Rights Reserved.
//
// See LICENSE for full license information.
//
// =================================================================================================
using System;
using UnityEngine;
using System.Collections;
namespace HammercLib.Utils
{
/// <summary>
/// 协程工具类, 用在非继承 MonoBehaviour 的类中方便的使用协程.
/// </summary>
public class CoroutineHelper : IDisposable
{
private GameObject _gameObject;
private MonoBehaviour _monoBehaviour;
/// <summary>
/// 构造函数.
/// </summary>
public CoroutineHelper()
{
_gameObject = new GameObject();
_gameObject.name = "CoroutineHelper";
_monoBehaviour = _gameObject.AddComponent<MonoBehaviour>();
}
/// <summary>
/// 设置为加载场景时不销毁本对象.
/// </summary>
public void DontDestroyOnLoad()
{
GameObject.DontDestroyOnLoad(_gameObject);
}
/// <summary>
/// 开始一个协程.
/// </summary>
/// <param name="routine">协程方法.</param>
/// <returns>协程对象.</returns>
public Coroutine StartCoroutine(IEnumerator routine)
{
return _monoBehaviour.StartCoroutine(routine);
}
/// <summary>
/// 停止一个协程.
/// </summary>
/// <param name="routine">协程对象.</param>
public void StopCoroutine(IEnumerator routine)
{
_monoBehaviour.StopCoroutine(routine);
}
/// <summary>
/// 停止一个协程.
/// </summary>
/// <param name="routine">协程方法.</param>
public void StopCoroutine(Coroutine routine)
{
_monoBehaviour.StopCoroutine(routine);
}
/// <summary>
/// 停止本类启动的所有协程.
/// </summary>
public void StopAllCoroutines()
{
_monoBehaviour.StopAllCoroutines();
}
/// <summary>
/// 销毁本对象.
/// </summary>
public void Dispose()
{
GameObject.Destroy(_gameObject);
}
}
}
| 25.609195 | 101 | 0.48474 | [
"MIT"
] | hammerc/hammerc-framework-unity3d | unitysource/4.x/Assets/HammercLib/Utils/CoroutineHelper.cs | 2,406 | C# |
#region License
// /*
// Microsoft Public License (Ms-PL)
// MonoGame - Copyright © 2009 The MonoGame Team
//
// All rights reserved.
//
// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
// accept the license, do not use the software.
//
// 1. Definitions
// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under
// U.S. copyright law.
//
// A "contribution" is the original software, or any additions or changes to the software.
// A "contributor" is any person that distributes its contribution under this license.
// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
//
// 2. Grant of Rights
// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,
// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,
// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
//
// 3. Conditions and Limitations
// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software,
// your patent license from such contributor to the software ends automatically.
// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution
// notices that are present in the software.
// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including
// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object
// code form, you may only do so under a license that complies with this license.
// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
// purpose and non-infringement.
// */
#endregion License
using System;
namespace Microsoft.Xna.Framework.Net
{
public enum NetworkSessionJoinError
{
SessionNotFound, // The session could not be found. Occurs if the session has ended after the matchmaking query but before the client joined, of if there is no network connectivity between the client and session host machines.
SessionNotJoinable, // The session exists but is not joinable. Occurs if the session is in progress but does not allow gamers to join a session in progress.
SessionFull, // The session exists but does not have any open slots for local signed-in gamers.
}
}
| 64.407407 | 280 | 0.76222 | [
"MIT"
] | Adrriii/MonoGame | MonoGame.Framework/Net/NetworkSessionJoinError.cs | 3,479 | C# |
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using P03_SalesDatabase.Data;
namespace P03_SalesDatabase.Data.Migrations
{
[DbContext(typeof(SalesContext))]
[Migration("20180707191221_SalesAddDateDefault")]
partial class SalesAddDateDefault
{
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "2.1.1-rtm-30846")
.HasAnnotation("Relational:MaxIdentifierLength", 128)
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
modelBuilder.Entity("P03_SalesDatabase.Data.Models.Customer", b =>
{
b.Property<int>("CustomerId")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<string>("CreditCardNumber");
b.Property<string>("Email")
.HasColumnType("VARCHAR(80)")
.HasMaxLength(80)
.IsUnicode(false);
b.Property<string>("Name")
.HasColumnType("NVARCHAR(100)")
.HasMaxLength(100)
.IsUnicode(true);
b.HasKey("CustomerId");
b.ToTable("Customers");
});
modelBuilder.Entity("P03_SalesDatabase.Data.Models.Product", b =>
{
b.Property<int>("ProductId")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<string>("Description")
.ValueGeneratedOnAdd()
.HasColumnType("NVARCHAR(250)")
.HasMaxLength(250)
.IsUnicode(true)
.HasDefaultValue("No description");
b.Property<string>("Name")
.HasColumnType("NVARCHAR(50)")
.HasMaxLength(50)
.IsUnicode(true);
b.Property<decimal>("Price")
.HasColumnType("SMALLMONEY");
b.Property<decimal>("Quantity")
.HasColumnType("DECIMAL(18,2)");
b.HasKey("ProductId");
b.ToTable("Products");
b.HasData(
new { ProductId = 1, Name = "Samsung Business Keyboard", Price = 365.44m, Quantity = 4m },
new { ProductId = 2, Name = "Gigabyte Business Sound Card", Price = 510.97m, Quantity = 1m },
new { ProductId = 3, Name = "ASUS Gaming Sound Card", Price = 240.04m, Quantity = 8m },
new { ProductId = 4, Name = "Gigabyte Science Motherboard", Price = 419.22m, Quantity = 5m },
new { ProductId = 5, Name = "MSI Gaming Keyboard", Price = 586.33m, Quantity = 7m },
new { ProductId = 6, Name = "Logitech Gaming Monitor", Price = 422.22m, Quantity = 3m },
new { ProductId = 7, Name = "ASUS Gaming Graphics Card", Price = 505.89m, Quantity = 4m },
new { ProductId = 8, Name = "AMD Business Mouse", Price = 330.14m, Quantity = 5m },
new { ProductId = 9, Name = "AMD Gaming Graphics Card", Price = 129.83m, Quantity = 10m },
new { ProductId = 10, Name = "Intel Science Graphics Card", Price = 679.69m, Quantity = 6m },
new { ProductId = 11, Name = "Gigabyte Business Monitor", Price = 215.47m, Quantity = 1m },
new { ProductId = 12, Name = "Cooler Master Gaming Chassis", Price = 576.11m, Quantity = 6m },
new { ProductId = 13, Name = "Samsung Gaming Keyboard", Price = 428.01m, Quantity = 6m },
new { ProductId = 14, Name = "Intel Business Mouse", Price = 239.84m, Quantity = 1m },
new { ProductId = 15, Name = "AMD Business Sound Card", Price = 386.18m, Quantity = 2m },
new { ProductId = 16, Name = "Cooler Master Gaming Keyboard", Price = 300.69m, Quantity = 7m },
new { ProductId = 17, Name = "MSI Business Processor", Price = 208.63m, Quantity = 3m },
new { ProductId = 18, Name = "Logitech Business Chassis", Price = 389.25m, Quantity = 8m },
new { ProductId = 19, Name = "Gigabyte Science Mouse", Price = 407.16m, Quantity = 4m },
new { ProductId = 20, Name = "AMD Business Graphics Card", Price = 622.48m, Quantity = 6m }
);
});
modelBuilder.Entity("P03_SalesDatabase.Data.Models.Sale", b =>
{
b.Property<int>("SaleId")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<int>("CustomerId");
b.Property<DateTime>("Date")
.ValueGeneratedOnAdd()
.HasColumnType("DATETIME2")
.HasDefaultValueSql("GETDATE()");
b.Property<int>("ProductId");
b.Property<int>("StoreId");
b.HasKey("SaleId");
b.HasIndex("CustomerId");
b.HasIndex("ProductId");
b.HasIndex("StoreId");
b.ToTable("Sales");
});
modelBuilder.Entity("P03_SalesDatabase.Data.Models.Store", b =>
{
b.Property<int>("StoreId")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<string>("Name")
.HasColumnType("NVARCHAR(80)")
.HasMaxLength(80)
.IsUnicode(true);
b.HasKey("StoreId");
b.ToTable("Stores");
});
modelBuilder.Entity("P03_SalesDatabase.Data.Models.Sale", b =>
{
b.HasOne("P03_SalesDatabase.Data.Models.Customer", "Customer")
.WithMany("Sales")
.HasForeignKey("CustomerId")
.OnDelete(DeleteBehavior.Cascade);
b.HasOne("P03_SalesDatabase.Data.Models.Product", "Product")
.WithMany("Sales")
.HasForeignKey("ProductId")
.OnDelete(DeleteBehavior.Cascade);
b.HasOne("P03_SalesDatabase.Data.Models.Store", "Store")
.WithMany("Sales")
.HasForeignKey("StoreId")
.OnDelete(DeleteBehavior.Cascade);
});
#pragma warning restore 612, 618
}
}
}
| 46.506098 | 125 | 0.50885 | [
"MIT"
] | AscenKeeprov/Databases-Advanced | Exercise4-CodeFirst/P03_SalesDatabase.Data/Migrations/20180707191221_SalesAddDateDefault.Designer.cs | 7,629 | C# |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[System.Serializable]
public class PlayerData
{
private int currentLvl { get; set; }
private int maxLvlRich { get; set; }
//private int[] collectable { get; set; }
private int[] nbTries { get; set; }
private int[] bestNbTries { get; set; }
public PlayerData(GameManager gameManager){
currentLvl = gameManager.CurrentLvl;
maxLvlRich = gameManager.MaxLvlRich;
//collectable = gameManager.Collectable;
nbTries = gameManager.NbTries;
bestNbTries = gameManager.BestNbTries;
}
public int CurrentLvl
{
get { return currentLvl; }
set { currentLvl = value; }
}
public int MaxLvlRich
{
get { return maxLvlRich; }
set { maxLvlRich = value; }
}
/*public int[] Collectable
{
get { return collectable; }
set { collectable = value; }
}*/
public int[] NbTries
{
get { return nbTries; }
set { nbTries= value; }
}
public int[] BestNbTries
{
get { return bestNbTries; }
set { bestNbTries = value; }
}
}
| 24.479167 | 48 | 0.598298 | [
"MIT"
] | remi-espie/KJam-WonderJam | Assets/Scripts/PlayerData.cs | 1,177 | C# |
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Threading.Tasks;
namespace GBX.NET.Json
{
public class GameBoxContractResolver : DefaultContractResolver
{
protected override List<MemberInfo> GetSerializableMembers(Type objectType)
{
if(objectType.BaseType == typeof(Task))
return new List<MemberInfo> { objectType.GetProperty("Result") };
return objectType
.GetProperties()
.Where(x => x.GetCustomAttribute<IgnoreDataMemberAttribute>() == null)
.Cast<MemberInfo>().ToList();
}
}
}
| 29.269231 | 86 | 0.668857 | [
"Unlicense"
] | ThaumicTom/gbx-net | GBX.NET.Json/GameBoxContractResolver.cs | 763 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
using Phonebook.Source.PeopleSoft.Models;
using Phonebook.Source.PeopleSoft.Models.Context;
namespace Phonebook.Source.PeopleSoft.Repositories {
public class OrgUnitRepository : IRepository<OrgUnit> {
private readonly ModelContext context;
private IMemoryCache cache;
public OrgUnitRepository (ModelContext context, IMemoryCache cache) {
this.context = context;
this.cache = cache;
}
public async Task<IEnumerable<OrgUnit>> Get () {
if (this.cache.TryGetValue (this.GetType().Name, out IEnumerable<OrgUnit> cachedOrgUnits)) {
return cachedOrgUnits;
}
var orgUnits = (await this.includeDependenciesAsync (context.OrgUnits)).Where (o => o.ParentId == null);
orgUnits = orgUnits.Select (o => GetCleanedOrgUnit (o));
this.cache.Set (this.GetType().Name, orgUnits);
return orgUnits;
}
public async Task<OrgUnit> Get (int id) {
if (this.cache.TryGetValue($"{this.GetType().Name}/{id}", out OrgUnit cachedOrgUnit))
{
return cachedOrgUnit;
}
var orgunit = (await this.includeDependenciesAsync (context.OrgUnits)).Single (d => d.Id == id);
orgunit = GetCleanedOrgUnit(orgunit);
this.cache.Set($"{this.GetType().Name}/{id}", orgunit);
return orgunit;
}
private OrgUnit GetCleanedOrgUnit (OrgUnit orgUnit) {
orgUnit.HeadOfOrgUnit = orgUnit.HeadOfOrgUnit == null ? null : GetCleanedPerson (orgUnit.HeadOfOrgUnit);
orgUnit.OrgUnitToFunctions = orgUnit.OrgUnitToFunctions == null ? null :
orgUnit.OrgUnitToFunctions.Select (f => {
f.OrgUnit = null;
f.Person = GetCleanedPerson (f.Person);
return f;
});
orgUnit.ChildOrgUnits = orgUnit.ChildOrgUnits.Select (o => GetCleanedOrgUnit (o));
orgUnit.Parent = null;
return orgUnit;
}
private Person GetCleanedPerson (Person person) {
person.OwnedOrgUnits = null;
person.OrgUnit = null;
person.OrgUnitFunctions = null;
return person;
}
private async Task<ICollection<OrgUnit>> includeDependenciesAsync (IQueryable<OrgUnit> query) {
return await query
.AsNoTracking ()
.Include (o => o.ChildOrgUnits)
.Include (o => o.OrgUnitToFunctions)
.ThenInclude (o => o.Person)
.Include (o => o.HeadOfOrgUnit)
.ToListAsync () // We need this always. If you remove this line you don't get the tree of the orgunit...
;
}
}
}
| 40.554054 | 120 | 0.593802 | [
"MIT"
] | T-Systems-MMS/phonebook | Phonebook.Source.PeopleSoft/src/Phonebook.Source.PeopleSoft/Repositories/OrgUnitRepository.cs | 3,003 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using NUnit.Framework;
namespace Atata.WebDriverSetup.IntegrationTests
{
public class DriverSetupTests : IntegrationTestFixture
{
[TestCase(BrowserNames.Chrome)]
public void AutoSetUp(string browserName)
{
var result = DriverSetup.AutoSetUp(browserName);
AssertDriverIsSetUp(result, browserName);
AssertVersionCache(browserName);
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.Valid))]
public void AutoSetUp(string[] browserNames)
{
var results = DriverSetup.AutoSetUp(browserNames);
AssertAutoSetUpDriverResults(results, browserNames);
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsNullValue))]
public void AutoSetUp_ThrowsArgumentNullException(string[] browserNames)
{
Assert.Throws<ArgumentNullException>(() =>
DriverSetup.AutoSetUp(browserNames));
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsUnsupportedValue))]
public void AutoSetUp_ThrowsArgumentException(string[] browserNames)
{
var exception = Assert.Throws<ArgumentException>(() =>
DriverSetup.AutoSetUp(browserNames));
exception.Message.Should().ContainEquivalentOf("unsupported");
}
[TestCase(BrowserNames.Chrome)]
public async Task AutoSetUpAsync(string browserName)
{
var result = await DriverSetup.AutoSetUpAsync(browserName);
AssertDriverIsSetUp(result, browserName);
AssertVersionCache(browserName);
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.Valid))]
public async Task AutoSetUpAsync(string[] browserNames)
{
var results = await DriverSetup.AutoSetUpAsync(browserNames);
AssertAutoSetUpDriverResults(results, browserNames);
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsNullValue))]
public void AutoSetUpAsync_ThrowsArgumentNullException(string[] browserNames)
{
Assert.ThrowsAsync<ArgumentNullException>(() =>
DriverSetup.AutoSetUpAsync(browserNames));
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsUnsupportedValue))]
public void AutoSetUpAsync_ThrowsArgumentException(string[] browserNames)
{
var exception = Assert.ThrowsAsync<ArgumentException>(() =>
DriverSetup.AutoSetUpAsync(browserNames));
exception.Message.Should().ContainEquivalentOf("unsupported");
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.Valid))]
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsNullValue))]
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsUnsupportedValue))]
public void AutoSetUpSafely(string[] browserNames)
{
var results = DriverSetup.AutoSetUpSafely(browserNames);
AssertAutoSetUpDriverResults(results, browserNames?.Where(IsValidBrowserName) ?? new string[0]);
}
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.Valid))]
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsNullValue))]
[TestCaseSource(typeof(BrowserNameSets), nameof(BrowserNameSets.ContainsUnsupportedValue))]
public async Task AutoSetUpSafelyAsync(string[] browserNames)
{
var results = await DriverSetup.AutoSetUpSafelyAsync(browserNames);
AssertAutoSetUpDriverResults(results, browserNames?.Where(IsValidBrowserName) ?? new string[0]);
}
private static void AssertAutoSetUpDriverResults(
IEnumerable<DriverSetupResult> setupResults,
IEnumerable<string> browserNames)
{
var distinctBrowserNames = browserNames.Distinct().ToArray();
setupResults.Should().HaveCount(distinctBrowserNames.Length);
foreach (string browserName in distinctBrowserNames)
{
var correspondingResult = setupResults.Should()
.ContainSingle(x => x.BrowserName == browserName)
.Subject;
AssertDriverIsSetUp(correspondingResult, browserName);
AssertVersionCache(browserName);
}
}
public static class BrowserNameSets
{
public static readonly IEnumerable<string[]> Valid = new[]
{
new[] { BrowserNames.Chrome },
new[] { BrowserNames.Chrome, BrowserNames.Chrome },
new[] { BrowserNames.Chrome, BrowserNames.Firefox }
};
public static readonly IEnumerable<string[]> ContainsNullValue = new string[][]
{
null,
new[] { null as string },
new[] { BrowserNames.Chrome, null }
};
public static readonly IEnumerable<string[]> ContainsUnsupportedValue = new string[][]
{
new[] { "Unknown" },
new[] { BrowserNames.Chrome, "Unknown" }
};
}
}
}
| 38.985714 | 108 | 0.647856 | [
"Apache-2.0"
] | atata-framework/atata-webdriversetup | test/Atata.WebDriverSetup.IntegrationTests/DriverSetupTests.cs | 5,460 | C# |
using System;
using Asn1;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Security.Principal;
using System.DirectoryServices;
using System.DirectoryServices.AccountManagement;
namespace Rubeus
{
public class Roast
{
public static void ASRepRoast(string userName, string domain, string domainController = "", string format = "john")
{
GetASRepHash(userName, domain, domainController, format);
}
public static void GetASRepHash(string userName, string domain, string domainController = "", string format = "")
{
// roast AS-REPs for users without pre-authentication enabled
Console.WriteLine("[*] Action: AS-REP Roasting");
// grab the default DC if none was supplied
if (String.IsNullOrEmpty(domainController)) {
domainController = Networking.GetDCName();
if(String.IsNullOrEmpty(domainController))
{
Console.WriteLine("[X] Error retrieving the current domain controller.");
return;
}
}
System.Net.IPAddress[] dcIP = null;
try
{
dcIP = System.Net.Dns.GetHostAddresses(domainController);
}
catch (Exception e) {
Console.WriteLine("[X] Error retrieving IP for domain controller \"{0}\" : {1}", domainController, e.Message);
return;
}
Console.WriteLine("\r\n[*] Using domain controller: {0} ({1})", domainController, dcIP[0]);
Console.WriteLine("[*] Building AS-REQ (w/o preauth) for: '{0}\\{1}'", domain, userName);
byte[] reqBytes = AS_REQ.NewASReq(userName, domain, Interop.KERB_ETYPE.rc4_hmac);
byte[] response = Networking.SendBytes(dcIP[0].ToString(), 88, reqBytes);
if (response == null)
{
return;
}
// decode the supplied bytes to an AsnElt object
// false == ignore trailing garbage
AsnElt responseAsn = AsnElt.Decode(response, false);
// check the response value
int responseTag = responseAsn.TagValue;
if (responseTag == 11)
{
Console.WriteLine("[+] AS-REQ w/o preauth successful!");
// parse the response to an AS-REP
AS_REP rep = new AS_REP(response);
// output the hash of the encrypted KERB-CRED in a crackable hash form
string repHash = BitConverter.ToString(rep.enc_part.cipher).Replace("-", string.Empty);
repHash = repHash.Insert(32, "$");
string hashString = "";
if(format == "john")
{
hashString = String.Format("$krb5asrep${0}@{1}:{2}", userName, domain, repHash);
}
else
{
// eventual hashcat format
hashString = String.Format("$krb5asrep${0}$*{1}${2}*${3}${4}", (int)Interop.KERB_ETYPE.rc4_hmac, userName, domain, repHash.Substring(0, 32), repHash.Substring(32));
}
Console.WriteLine("[*] AS-REP hash:\r\n");
// display the base64 of a hash, columns of 80 chararacters
foreach (string line in Helpers.Split(hashString, 80))
{
Console.WriteLine(" {0}", line);
}
}
else if (responseTag == 30)
{
// parse the response to an KRB-ERROR
KRB_ERROR error = new KRB_ERROR(responseAsn.Sub[0]);
Console.WriteLine("\r\n[X] KRB-ERROR ({0}) : {1}\r\n", error.error_code, (Interop.KERBEROS_ERROR)error.error_code);
}
else
{
Console.WriteLine("\r\n[X] Unknown application tag: {0}", responseTag);
}
}
public static void Kerberoast(string spn = "", string userName = "", string OUName = "", System.Net.NetworkCredential cred = null)
{
Console.WriteLine("[*] Action: Kerberoasting");
if (!String.IsNullOrEmpty(spn))
{
Console.WriteLine("\r\n[*] ServicePrincipalName : {0}", spn);
GetDomainSPNTicket(spn);
}
else
{
DirectoryEntry directoryObject = null;
DirectorySearcher userSearcher = null;
string bindPath = "";
try
{
if (cred != null)
{
if (!String.IsNullOrEmpty(OUName))
{
string ouPath = OUName.Replace("ldap", "LDAP").Replace("LDAP://", "");
bindPath = String.Format("LDAP://{0}/{1}", cred.Domain, ouPath);
}
else
{
bindPath = String.Format("LDAP://{0}", cred.Domain);
}
}
else if (!String.IsNullOrEmpty(OUName))
{
string ouPath = OUName.Replace("ldap", "LDAP").Replace("LDAP://", "");
bindPath = String.Format("LDAP://{0}", ouPath);
}
if (!String.IsNullOrEmpty(bindPath))
{
directoryObject = new DirectoryEntry(bindPath);
}
else
{
directoryObject = new DirectoryEntry();
}
if (cred != null)
{
// if we're using alternate credentials for the connection
string userDomain = String.Format("{0}\\{1}", cred.Domain, cred.UserName);
directoryObject.Username = userDomain;
directoryObject.Password = cred.Password;
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, cred.Domain))
{
if (!pc.ValidateCredentials(cred.UserName, cred.Password))
{
Console.WriteLine("\r\n[X] Credentials supplied for '{0}' are invalid!", userDomain);
return;
}
}
}
userSearcher = new DirectorySearcher(directoryObject);
}
catch (Exception ex)
{
Console.WriteLine("\r\n[X] Error creating the domain searcher: {0}", ex.InnerException.Message);
return;
}
// check to ensure that the bind worked correctly
try
{
Guid guid = directoryObject.Guid;
}
catch (DirectoryServicesCOMException ex)
{
if (!String.IsNullOrEmpty(OUName))
{
Console.WriteLine("\r\n[X] Error creating the domain searcher for bind path \"{0}\" : {1}", OUName, ex.Message);
}
else
{
Console.WriteLine("\r\n[X] Error creating the domain searcher: {0}", ex.Message);
}
return;
}
try
{
if (String.IsNullOrEmpty(userName))
{
userSearcher.Filter = "(&(samAccountType=805306368)(servicePrincipalName=*)(!samAccountName=krbtgt))";
}
else
{
userSearcher.Filter = String.Format("(&(samAccountType=805306368)(servicePrincipalName=*)(samAccountName={0}))", userName);
}
}
catch (Exception ex)
{
Console.WriteLine("\r\n[X] Error settings the domain searcher filter: {0}", ex.InnerException.Message);
return;
}
try
{
SearchResultCollection users = userSearcher.FindAll();
foreach (SearchResult user in users)
{
string samAccountName = user.Properties["samAccountName"][0].ToString();
string distinguishedName = user.Properties["distinguishedName"][0].ToString();
string servicePrincipalName = user.Properties["servicePrincipalName"][0].ToString();
Console.WriteLine("\r\n[*] SamAccountName : {0}", samAccountName);
Console.WriteLine("[*] DistinguishedName : {0}", distinguishedName);
Console.WriteLine("[*] ServicePrincipalName : {0}", servicePrincipalName);
GetDomainSPNTicket(servicePrincipalName, userName, distinguishedName, cred);
}
}
catch (Exception ex)
{
Console.WriteLine("\r\n [X] Error executing the domain searcher: {0}", ex.InnerException.Message);
return;
}
}
//else - search for user/OU/etc.
}
public static void GetDomainSPNTicket(string spn, string userName = "user", string distinguishedName = "", System.Net.NetworkCredential cred = null)
{
string domain = "DOMAIN";
if (Regex.IsMatch(distinguishedName, "^CN=.*", RegexOptions.IgnoreCase))
{
// extract the domain name from the distinguishedname
Match dnMatch = Regex.Match(distinguishedName, "(?<Domain>DC=.*)", RegexOptions.IgnoreCase);
string domainDN = dnMatch.Groups["Domain"].ToString();
domain = domainDN.Replace("DC=", "").Replace(',', '.');
}
try
{
// the System.IdentityModel.Tokens.KerberosRequestorSecurityToken approach and extraction of the AP-REQ from the
// GetRequest() stream was constributed to PowerView by @machosec
System.IdentityModel.Tokens.KerberosRequestorSecurityToken ticket;
if (cred != null)
{
ticket = new System.IdentityModel.Tokens.KerberosRequestorSecurityToken(spn, TokenImpersonationLevel.Impersonation, cred, Guid.NewGuid().ToString());
}
else
{
ticket = new System.IdentityModel.Tokens.KerberosRequestorSecurityToken(spn);
}
byte[] requestBytes = ticket.GetRequest();
if ( !((requestBytes[15] == 1) && (requestBytes[16] == 0)) )
{
Console.WriteLine("\r\n[X] GSSAPI inner token is not an AP_REQ.\r\n");
return;
}
// ignore the GSSAPI frame
byte[] apReqBytes = new byte[requestBytes.Length-17];
Array.Copy(requestBytes, 17, apReqBytes, 0, requestBytes.Length - 17);
AsnElt apRep = AsnElt.Decode(apReqBytes);
if (apRep.TagValue != 14)
{
Console.WriteLine("\r\n[X] Incorrect ASN application tag. Expected 14, but got {0}.\r\n", apRep.TagValue);
}
long encType = 0;
foreach (AsnElt elem in apRep.Sub[0].Sub)
{
if (elem.TagValue == 3)
{
foreach (AsnElt elem2 in elem.Sub[0].Sub[0].Sub)
{
if(elem2.TagValue == 3)
{
foreach (AsnElt elem3 in elem2.Sub[0].Sub)
{
if (elem3.TagValue == 0)
{
encType = elem3.Sub[0].GetInteger();
}
if (elem3.TagValue == 2)
{
byte[] cipherTextBytes = elem3.Sub[0].GetOctetString();
string cipherText = BitConverter.ToString(cipherTextBytes).Replace("-", "");
string hash = String.Format("$krb5tgs${0}$*{1}${2}${3}*${4}${5}", encType, userName, domain, spn, cipherText.Substring(0, 32), cipherText.Substring(32));
bool header = false;
foreach (string line in Helpers.Split(hash, 80))
{
if (!header)
{
Console.WriteLine("[*] Hash : {0}", line);
}
else
{
Console.WriteLine(" {0}", line);
}
header = true;
}
Console.WriteLine();
}
}
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("\r\n [X] Error during request for SPN {0} : {1}\r\n", spn, ex.InnerException.Message);
}
}
}
} | 44.17378 | 194 | 0.436469 | [
"BSD-3-Clause"
] | mark-s/Rubeus | Rubeus/lib/Roast.cs | 14,491 | C# |
// Seq Client for .NET - Copyright 2014 Continuous IT Pty Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using Serilog.Core;
using Serilog.Events;
using Serilog.Formatting.Json;
using Serilog.Sinks.RollingFile;
namespace Serilog.Sinks.Seq
{
class DurableSeqSink : ILogEventSink, IDisposable
{
readonly HttpLogShipper _shipper;
readonly RollingFileSink _sink;
public DurableSeqSink(string serverUrl, string bufferBaseFilename, string apiKey, int batchPostingLimit, TimeSpan period, long? bufferFileSizeLimitBytes)
{
if (serverUrl == null) throw new ArgumentNullException("serverUrl");
if (bufferBaseFilename == null) throw new ArgumentNullException("bufferBaseFilename");
_shipper = new HttpLogShipper(serverUrl, bufferBaseFilename, apiKey, batchPostingLimit, period);
_sink = new RollingFileSink(
bufferBaseFilename + "-{Date}.json",
new JsonFormatter(),
bufferFileSizeLimitBytes,
null);
}
public void Dispose()
{
_sink.Dispose();
_shipper.Dispose();
}
public void Emit(LogEvent logEvent)
{
// This is a lagging indicator, but the network bandwidth usage benefits
// are worth the ambiguity.
var minimumAcceptedLevel = _shipper.MinimumAcceptedLevel;
if (minimumAcceptedLevel == null ||
(int)minimumAcceptedLevel <= (int)logEvent.Level)
{
_sink.Emit(logEvent);
}
}
}
}
| 35.716667 | 161 | 0.654223 | [
"Apache-2.0"
] | Mpdreamz/serilog | src/Serilog.Sinks.Seq/Sinks/Seq/DurableSeqSink.cs | 2,145 | C# |
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NettyRPC.Core
{
/// <summary>
/// 表示Api行为表
/// </summary>
internal class ApiActionTable
{
/// <summary>
/// Api行为字典
/// </summary>
private readonly Dictionary<string, ApiAction> dictionary;
/// <summary>
/// Api行为表
/// </summary>
public ApiActionTable()
{
this.dictionary = new Dictionary<string, ApiAction>(StringComparer.CurrentCultureIgnoreCase);
}
/// <summary>
/// Api行为列表
/// </summary>
/// <param name="apiActions">Api行为</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public ApiActionTable(IEnumerable<ApiAction> apiActions)
: this()
{
this.AddRange(apiActions);
}
/// <summary>
/// 添加Api行为
/// </summary>
/// <param name="apiAction">Api行为</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void Add(ApiAction apiAction)
{
if (apiAction == null)
{
throw new ArgumentNullException("apiAction");
}
if (this.dictionary.ContainsKey(apiAction.ApiName))
{
throw new ArgumentException(string.Format("Api行为{0}或其命令值已存在", apiAction.ApiName));
}
this.dictionary.Add(apiAction.ApiName, apiAction);
}
/// <summary>
/// 添加Api行为
/// </summary>
/// <param name="apiActions">Api行为</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void AddRange(IEnumerable<ApiAction> apiActions)
{
foreach (var action in apiActions)
{
this.Add(action);
}
}
/// <summary>
/// 获取Api行为
/// 如果获取不到则返回null
/// </summary>
/// <param name="name">行为名称</param>
/// <returns></returns>
public ApiAction TryGetAndClone(string name)
{
ApiAction apiAction;
if (this.dictionary.TryGetValue(name, out apiAction))
{
return ((ICloneable<ApiAction>)apiAction).CloneConstructor();
}
return null;
}
}
}
| 28.472527 | 105 | 0.536086 | [
"MIT"
] | wangweinjcn/nettyRpc | spNettyRPC/Core/Internal/ApiActionTable.cs | 2,707 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Test120")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Test120")]
[assembly: AssemblyCopyright("Copyright © 2012")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("a95af2e8-aa96-4054-93f3-79c53fa0b39d")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| 38.459459 | 85 | 0.724526 | [
"BSD-2-Clause"
] | reddaiahece/bo-utils | bo-test120/Properties/AssemblyInfo.cs | 1,426 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class StartUp
{
public static void Main()
{
var people = new List<Person>();
var searchedPersonParam = Console.ReadLine();
while (true)
{
var input = Console.ReadLine();
if (input == "End") break;
if (input.Contains("-"))
{
var tokens = input
.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToArray();
var parentToken = tokens[0];
var childToken = tokens[1];
var parent = CreatePerson(parentToken);
var child = CreatePerson(childToken);
AddParentIfMissing(people, parent);
if (parent.Name != null)
{
people.FirstOrDefault(p => p.Name == parent.Name)
.AddChild(child);
}
else
{
people.FirstOrDefault(p => p.Birthdate == parent.Birthdate)
.AddChild(child);
}
}
else
{
var tokens = input
.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var name = $"{tokens[0]} {tokens[1]}";
var birthdate = tokens[2];
var isExistingPerson = false;
for (int i = 0; i < people.Count; i++)
{
if (people[i].Name == name)
{
people[i].Birthdate = birthdate;
isExistingPerson = true;
}
if (people[i].Birthdate == birthdate)
{
people[i].Name = name;
isExistingPerson = true;
}
people[i].AddChildrenInfo(name, birthdate);
}
if (!isExistingPerson)
{
people.Add(new Person(name, birthdate));
}
}
}
PrintParentsAndChildren(people, searchedPersonParam);
}
private static Person CreatePerson(string personParam)
{
var person = new Person();
if (IsDate(personParam))
{
person.Birthdate = personParam;
}
else
{
person.Name = personParam;
}
return person;
}
private static void PrintParentsAndChildren(List<Person> people, string personParam)
{
Person person = people.FirstOrDefault(p => p.Birthdate == personParam ||
p.Name == personParam);
var builder = new StringBuilder();
builder.AppendLine($"{person.Name} {person.Birthdate}");
builder.AppendLine("Parents:");
people.Where(p => p.FindChild(person.Name) != null)
.ToList()
.ForEach(p => builder.AppendLine($"{p.Name} {p.Birthdate}"));
builder.AppendLine("Children:");
person.Children
.ToList()
.ForEach(c => builder.AppendLine($"{c.Name} {c.Birthdate}"));
Console.WriteLine(builder);
}
private static void AddParentIfMissing(List<Person> people, Person parent)
{
if ((parent.Name != null && people.Any(p => p.Name == parent.Name)) ||
(parent.Birthdate != null & people.Any(p => p.Birthdate == parent.Birthdate)))
{
return;
}
people.Add(parent);
}
public static bool IsDate(string s)
{
return s.Contains("/");
}
} | 30.188976 | 90 | 0.460616 | [
"MIT"
] | Shtereva/CSharp-OOP-Basics | Defining Classes/13. Family Tree/StartUp.cs | 3,836 | C# |
/*****************************************************************************
* Copyright 2016 Aurora Solutions
*
* http://www.aurorasolutions.io
*
* Aurora Solutions is an innovative services and product company at
* the forefront of the software industry, with processes and practices
* involving Domain Driven Design(DDD), Agile methodologies to build
* scalable, secure, reliable and high performance products.
*
* Coin Exchange is a high performance exchange system specialized for
* Crypto currency trading. It has different general purpose uses such as
* independent deposit and withdrawal channels for Bitcoin and Litecoin,
* but can also act as a standalone exchange that can be used with
* different asset classes.
* Coin Exchange uses state of the art technologies such as ASP.NET REST API,
* AngularJS and NUnit. It also uses design patterns for complex event
* processing and handling of thousands of transactions per second, such as
* Domain Driven Designing, Disruptor Pattern and CQRS With Event Sourcing.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CoinExchange.Common.Domain.Model;
using CoinExchange.Trades.Domain.Model.OrderAggregate;
using CoinExchange.Trades.Domain.Model.TradeAggregate;
namespace CoinExchange.Trades.Application.OrderServices.Commands
{
public class CancelOrderCommand
{
public OrderId OrderId { get; private set; }
public TraderId TraderId { get; private set; }
public CancelOrderCommand(OrderId orderId, TraderId traderId)
{
AssertionConcern.AssertArgumentNotNull(orderId,"OrderId not provided or it is invalid");
AssertionConcern.AssertArgumentNotNull(traderId,"TraderId not provided or it is invalid");
OrderId = orderId;
TraderId = traderId;
}
}
}
| 43.066667 | 103 | 0.692337 | [
"Apache-2.0"
] | 3plcoins/coin-exchange-backend | src/Trades/CoinExchange.Trades.Application/OrderServices/Commands/CancelOrderCommand.cs | 2,586 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
namespace WebAppTokenVault
{
public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
}
}
| 26.136364 | 70 | 0.709565 | [
"MIT"
] | galiniliev/app-service-msi-tokenvault-dotnet | WebAppTokenVault/WebAppTokenVault/Global.asax.cs | 577 | C# |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// <auto-generated/>
#nullable disable
using System.Collections.Generic;
using System.Text.Json;
using Azure.Core;
using Azure.ResourceManager.Models;
namespace Azure.ResourceManager.Resources.Models
{
public partial class PatchableApplicationData : IUtf8JsonSerializable
{
void IUtf8JsonSerializable.Write(Utf8JsonWriter writer)
{
writer.WriteStartObject();
if (Optional.IsDefined(Plan))
{
writer.WritePropertyName("plan");
JsonSerializer.Serialize(writer, Plan);
}
if (Optional.IsDefined(Kind))
{
writer.WritePropertyName("kind");
writer.WriteStringValue(Kind);
}
if (Optional.IsDefined(Identity))
{
writer.WritePropertyName("identity");
writer.WriteObjectValue(Identity);
}
if (Optional.IsDefined(ManagedBy))
{
writer.WritePropertyName("managedBy");
writer.WriteStringValue(ManagedBy);
}
if (Optional.IsDefined(Sku))
{
writer.WritePropertyName("sku");
writer.WriteObjectValue(Sku);
}
writer.WritePropertyName("tags");
writer.WriteStartObject();
foreach (var item in Tags)
{
writer.WritePropertyName(item.Key);
writer.WriteStringValue(item.Value);
}
writer.WriteEndObject();
writer.WritePropertyName("location");
writer.WriteStringValue(Location);
writer.WritePropertyName("properties");
writer.WriteStartObject();
if (Optional.IsDefined(ManagedResourceGroupId))
{
writer.WritePropertyName("managedResourceGroupId");
writer.WriteStringValue(ManagedResourceGroupId);
}
if (Optional.IsDefined(ApplicationDefinitionId))
{
writer.WritePropertyName("applicationDefinitionId");
writer.WriteStringValue(ApplicationDefinitionId);
}
if (Optional.IsDefined(Parameters))
{
writer.WritePropertyName("parameters");
writer.WriteObjectValue(Parameters);
}
if (Optional.IsDefined(JitAccessPolicy))
{
writer.WritePropertyName("jitAccessPolicy");
writer.WriteObjectValue(JitAccessPolicy);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
internal static PatchableApplicationData DeserializePatchableApplicationData(JsonElement element)
{
Optional<Plan> plan = default;
Optional<string> kind = default;
Optional<ApplicationManagedIdentity> identity = default;
Optional<string> managedBy = default;
Optional<ApplicationSku> sku = default;
IDictionary<string, string> tags = default;
AzureLocation location = default;
ResourceIdentifier id = default;
string name = default;
ResourceType type = default;
SystemData systemData = default;
Optional<string> managedResourceGroupId = default;
Optional<string> applicationDefinitionId = default;
Optional<object> parameters = default;
Optional<object> outputs = default;
Optional<ProvisioningState> provisioningState = default;
Optional<ApplicationBillingDetailsDefinition> billingDetails = default;
Optional<ApplicationJitAccessPolicy> jitAccessPolicy = default;
Optional<string> publisherTenantId = default;
Optional<IReadOnlyList<ApplicationAuthorization>> authorizations = default;
Optional<ApplicationManagementMode> managementMode = default;
Optional<ApplicationPackageContact> customerSupport = default;
Optional<ApplicationPackageSupportUrls> supportUrls = default;
Optional<IReadOnlyList<ApplicationArtifact>> artifacts = default;
Optional<ApplicationClientDetails> createdBy = default;
Optional<ApplicationClientDetails> updatedBy = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("plan"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
plan = JsonSerializer.Deserialize<Plan>(property.Value.ToString());
continue;
}
if (property.NameEquals("kind"))
{
kind = property.Value.GetString();
continue;
}
if (property.NameEquals("identity"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
identity = ApplicationManagedIdentity.DeserializeApplicationManagedIdentity(property.Value);
continue;
}
if (property.NameEquals("managedBy"))
{
managedBy = property.Value.GetString();
continue;
}
if (property.NameEquals("sku"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
sku = ApplicationSku.DeserializeApplicationSku(property.Value);
continue;
}
if (property.NameEquals("tags"))
{
Dictionary<string, string> dictionary = new Dictionary<string, string>();
foreach (var property0 in property.Value.EnumerateObject())
{
dictionary.Add(property0.Name, property0.Value.GetString());
}
tags = dictionary;
continue;
}
if (property.NameEquals("location"))
{
location = property.Value.GetString();
continue;
}
if (property.NameEquals("id"))
{
id = new ResourceIdentifier(property.Value.GetString());
continue;
}
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("type"))
{
type = property.Value.GetString();
continue;
}
if (property.NameEquals("systemData"))
{
systemData = JsonSerializer.Deserialize<SystemData>(property.Value.ToString());
continue;
}
if (property.NameEquals("properties"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
foreach (var property0 in property.Value.EnumerateObject())
{
if (property0.NameEquals("managedResourceGroupId"))
{
managedResourceGroupId = property0.Value.GetString();
continue;
}
if (property0.NameEquals("applicationDefinitionId"))
{
applicationDefinitionId = property0.Value.GetString();
continue;
}
if (property0.NameEquals("parameters"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
parameters = property0.Value.GetObject();
continue;
}
if (property0.NameEquals("outputs"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
outputs = property0.Value.GetObject();
continue;
}
if (property0.NameEquals("provisioningState"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
provisioningState = new ProvisioningState(property0.Value.GetString());
continue;
}
if (property0.NameEquals("billingDetails"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
billingDetails = ApplicationBillingDetailsDefinition.DeserializeApplicationBillingDetailsDefinition(property0.Value);
continue;
}
if (property0.NameEquals("jitAccessPolicy"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
jitAccessPolicy = ApplicationJitAccessPolicy.DeserializeApplicationJitAccessPolicy(property0.Value);
continue;
}
if (property0.NameEquals("publisherTenantId"))
{
publisherTenantId = property0.Value.GetString();
continue;
}
if (property0.NameEquals("authorizations"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List<ApplicationAuthorization> array = new List<ApplicationAuthorization>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(ApplicationAuthorization.DeserializeApplicationAuthorization(item));
}
authorizations = array;
continue;
}
if (property0.NameEquals("managementMode"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
managementMode = new ApplicationManagementMode(property0.Value.GetString());
continue;
}
if (property0.NameEquals("customerSupport"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
customerSupport = ApplicationPackageContact.DeserializeApplicationPackageContact(property0.Value);
continue;
}
if (property0.NameEquals("supportUrls"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
supportUrls = ApplicationPackageSupportUrls.DeserializeApplicationPackageSupportUrls(property0.Value);
continue;
}
if (property0.NameEquals("artifacts"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List<ApplicationArtifact> array = new List<ApplicationArtifact>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(ApplicationArtifact.DeserializeApplicationArtifact(item));
}
artifacts = array;
continue;
}
if (property0.NameEquals("createdBy"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
createdBy = ApplicationClientDetails.DeserializeApplicationClientDetails(property0.Value);
continue;
}
if (property0.NameEquals("updatedBy"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
updatedBy = ApplicationClientDetails.DeserializeApplicationClientDetails(property0.Value);
continue;
}
}
continue;
}
}
return new PatchableApplicationData(id, name, type, systemData, tags, location, managedBy.Value, sku.Value, plan, kind.Value, identity.Value, managedResourceGroupId.Value, applicationDefinitionId.Value, parameters.Value, outputs.Value, Optional.ToNullable(provisioningState), billingDetails.Value, jitAccessPolicy.Value, publisherTenantId.Value, Optional.ToList(authorizations), Optional.ToNullable(managementMode), customerSupport.Value, supportUrls.Value, Optional.ToList(artifacts), createdBy.Value, updatedBy.Value);
}
}
}
| 46.531609 | 532 | 0.465633 | [
"MIT"
] | yifan-zhou922/azure-sdk-for-net | sdk/resources/Azure.ResourceManager.Resources/src/Generated/Models/PatchableApplicationData.Serialization.cs | 16,193 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.5472
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace PKExtDesigner.Properties {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "9.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default {
get {
return defaultInstance;
}
}
}
}
| 39.481481 | 150 | 0.581614 | [
"BSD-3-Clause"
] | pradeepkodical/ExtDesigner | PKExtDesigner/Properties/Settings.Designer.cs | 1,068 | C# |
using System;
using Newtonsoft.Json;
using PipelineFramework;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Collections.Generic;
namespace ItemBuilder.Middleware
{
public class PrintMiddleware : BaseMiddleware
{
public PrintMiddleware() : base("Print Middleware", "PMW") { }
public override Task Process(MiddlewareRequest request)
{
var timer = new Stopwatch();
timer.Start();
try
{
var items = JsonConvert.DeserializeObject<List<Item>>(request.Request);
foreach(var item in items)
{
Console.WriteLine($"ID: {item.Id}");
Console.WriteLine($"Name: {item.Id}");
Console.WriteLine($"Description: {item.Id}");
Console.WriteLine($"SKU: {item.SKU}");
Console.WriteLine($"Cost: {item.Cost}");
}
timer.Stop();
var response = new MiddlewareResponse()
{
Response = JsonConvert.SerializeObject(items),
CompletedAt = DateTime.UtcNow,
TimeTaken = timer.Elapsed,
ExecutionConfiguration = request.ExecutionConfiguration
};
return Complete(response);
}
catch (Exception error)
{
timer.Stop();
var response = new MiddlewareExceptionResponse()
{
Exception = error,
CompletedAt = DateTime.UtcNow,
TimeTaken = timer.Elapsed,
ExecutionConfiguration = request.ExecutionConfiguration
};
return Abort(response);
}
}
}
} | 33.581818 | 87 | 0.507309 | [
"MIT"
] | patrickCode/Design-Patterns | PipelineFramework/ServiceBuilder/Middleware/PrintMiddleware.cs | 1,849 | C# |
using AI.BackEnds.DSP.NWaves.FeatureExtractors.Base;
using AI.BackEnds.DSP.NWaves.FeatureExtractors.Options;
using AI.BackEnds.DSP.NWaves.Filters;
using AI.BackEnds.DSP.NWaves.Filters.Fda;
using AI.BackEnds.DSP.NWaves.Transforms;
using AI.BackEnds.DSP.NWaves.Utils;
using AI.BackEnds.DSP.NWaves.Windows;
using System;
using System.Collections.Generic;
using System.Linq;
namespace AI.BackEnds.DSP.NWaves.FeatureExtractors
{
/// <summary>
/// Perceptual Linear Predictive Coefficients extractor (PLP-RASTA)
/// </summary>
public class PlpExtractor : FeatureExtractor
{
/// <summary>
/// Descriptions (simply "plp0", "plp1", "plp2", etc.)
/// </summary>
public override List<string> FeatureDescriptions
{
get
{
List<string> names = Enumerable.Range(0, FeatureCount).Select(i => "plp" + i).ToList();
if (_includeEnergy)
{
names[0] = "log_En";
}
return names;
}
}
/// <summary>
/// Filterbank matrix of dimension [filterbankSize * (fftSize/2 + 1)].
/// By default it's bark filterbank like in original H.Hermansky's work
/// (although many people prefer mel bands).
/// </summary>
public float[][] FilterBank { get; }
/// <summary>
/// Filterbank center frequencies
/// </summary>
protected readonly double[] _centerFrequencies;
/// <summary>
/// RASTA coefficient (if zero, then no RASTA filtering)
/// </summary>
protected readonly double _rasta;
/// <summary>
/// RASTA filters for each critical band
/// </summary>
protected readonly RastaFilter[] _rastaFilters;
/// <summary>
/// Size of liftering window
/// </summary>
protected readonly int _lifterSize;
/// <summary>
/// Liftering window coefficients
/// </summary>
protected readonly float[] _lifterCoeffs;
/// <summary>
/// Should the first PLP coefficient be replaced with LOG(energy)
/// </summary>
protected readonly bool _includeEnergy;
/// <summary>
/// Floor value for LOG-energy calculation
/// </summary>
protected readonly float _logEnergyFloor;
/// <summary>
/// FFT transformer
/// </summary>
protected readonly RealFft _fft;
/// <summary>
/// Internal buffer for a signal spectrum at each step
/// </summary>
protected readonly float[] _spectrum;
/// <summary>
/// Internal buffer for a signal spectrum grouped to frequency bands
/// </summary>
protected readonly float[] _bandSpectrum;
/// <summary>
/// Equal loudness weighting coefficients
/// </summary>
protected readonly double[] _equalLoudnessCurve;
/// <summary>
/// LPC order
/// </summary>
protected readonly int _lpcOrder;
/// <summary>
/// Internal buffer for LPC-coefficients
/// </summary>
protected readonly float[] _lpc;
/// <summary>
/// Precomputed IDFT table
/// </summary>
protected readonly float[][] _idftTable;
/// <summary>
/// Autocorrelation samples (computed as IDFT of power spectrum)
/// </summary>
protected readonly float[] _cc;
/// <summary>
/// Constructor
/// </summary>
/// <param name="options">PLP options</param>
public PlpExtractor(PlpOptions options) : base(options)
{
FeatureCount = options.FeatureCount;
// ================================ Prepare filter bank and center frequencies: ===========================================
int filterbankSize = options.FilterBankSize;
if (options.FilterBank == null)
{
_blockSize = options.FftSize > FrameSize ? options.FftSize : MathUtils.NextPowerOfTwo(FrameSize);
double low = options.LowFrequency;
double high = options.HighFrequency;
FilterBank = FilterBanks.BarkBankSlaney(filterbankSize, _blockSize, SamplingRate, low, high);
Tuple<double, double, double>[] barkBands = FilterBanks.BarkBandsSlaney(filterbankSize, SamplingRate, low, high);
_centerFrequencies = barkBands.Select(b => b.Item2).ToArray();
}
else
{
FilterBank = options.FilterBank;
filterbankSize = FilterBank.Length;
_blockSize = 2 * (FilterBank[0].Length - 1);
Guard.AgainstExceedance(FrameSize, _blockSize, "frame size", "FFT size");
if (options.CenterFrequencies != null)
{
_centerFrequencies = options.CenterFrequencies;
}
else
{
double herzResolution = (double)SamplingRate / _blockSize;
// try to determine center frequencies automatically from filterbank weights:
_centerFrequencies = new double[filterbankSize];
for (int i = 0; i < FilterBank.Length; i++)
{
int minPos = 0;
int maxPos = _blockSize / 2;
for (int j = 0; j < FilterBank[i].Length; j++)
{
if (FilterBank[i][j] > 0)
{
minPos = j;
break;
}
}
for (int j = minPos; j < FilterBank[i].Length; j++)
{
if (FilterBank[i][j] == 0)
{
maxPos = j;
break;
}
}
_centerFrequencies[i] = herzResolution * (maxPos + minPos) / 2;
}
}
}
// ==================================== Compute equal loudness curve: =========================================
_equalLoudnessCurve = new double[filterbankSize];
for (int i = 0; i < _centerFrequencies.Length; i++)
{
double level2 = _centerFrequencies[i] * _centerFrequencies[i];
_equalLoudnessCurve[i] = Math.Pow(level2 / (level2 + 1.6e5), 2) * ((level2 + 1.44e6) / (level2 + 9.61e6));
}
// ============================== Prepare RASTA filters (if necessary): =======================================
_rasta = options.Rasta;
if (_rasta > 0)
{
_rastaFilters = Enumerable.Range(0, filterbankSize)
.Select(f => new RastaFilter(_rasta))
.ToArray();
}
// ============== Precompute IDFT table for obtaining autocorrelation coeffs from power spectrum: =============
_lpcOrder = options.LpcOrder > 0 ? options.LpcOrder : FeatureCount - 1;
_idftTable = new float[_lpcOrder + 1][];
int bandCount = filterbankSize + 2; // +2 duplicated edges
double freq = Math.PI / (bandCount - 1);
for (int i = 0; i < _idftTable.Length; i++)
{
_idftTable[i] = new float[bandCount];
_idftTable[i][0] = 1.0f;
for (int j = 1; j < bandCount - 1; j++)
{
_idftTable[i][j] = 2 * (float)Math.Cos(freq * i * j);
}
_idftTable[i][bandCount - 1] = (float)Math.Cos(freq * i * (bandCount - 1));
}
_lpc = new float[_lpcOrder + 1];
_cc = new float[bandCount];
// =================================== Prepare everything else: ==============================
_fft = new RealFft(_blockSize);
_lifterSize = options.LifterSize;
_lifterCoeffs = _lifterSize > 0 ? Window.Liftering(FeatureCount, _lifterSize) : null;
_includeEnergy = options.IncludeEnergy;
_logEnergyFloor = options.LogEnergyFloor;
_spectrum = new float[_blockSize / 2 + 1];
_bandSpectrum = new float[filterbankSize];
}
/// <summary>
/// Standard method for computing PLP features.
/// In each frame do:
///
/// 0) Apply window (base extractor does it)
/// 1) Obtain power spectrum
/// 2) Apply filterbank of bark bands (or mel bands)
/// 3) [Optional] filter each component of the processed spectrum with a RASTA filter
/// 4) Apply equal loudness curve
/// 5) Take cubic root
/// 6) Do LPC
/// 7) Convert LPC to cepstrum
/// 8) [Optional] lifter cepstrum
///
/// </summary>
/// <param name="block">Samples for analysis</param>
/// <param name="features">PLP vectors</param>
public override void ProcessFrame(float[] block, float[] features)
{
// 1) calculate power spectrum (without normalization)
_fft.PowerSpectrum(block, _spectrum, false);
// 2) apply filterbank on the result (bark frequencies by default)
FilterBanks.Apply(FilterBank, _spectrum, _bandSpectrum);
// 3) RASTA filtering in log-domain [optional]
if (_rasta > 0)
{
for (int k = 0; k < _bandSpectrum.Length; k++)
{
float log = (float)Math.Log(_bandSpectrum[k] + float.Epsilon);
log = _rastaFilters[k].Process(log);
_bandSpectrum[k] = (float)Math.Exp(log);
}
}
// 4) and 5) apply equal loudness curve and take cubic root
for (int k = 0; k < _bandSpectrum.Length; k++)
{
_bandSpectrum[k] = (float)Math.Pow(Math.Max(_bandSpectrum[k], 1.0) * _equalLoudnessCurve[k], 0.33);
}
// 6) LPC from power spectrum:
int n = _idftTable[0].Length;
// get autocorrelation samples from post-processed power spectrum (via IDFT):
for (int k = 0; k < _idftTable.Length; k++)
{
float acc = _idftTable[k][0] * _bandSpectrum[0] +
_idftTable[k][n - 1] * _bandSpectrum[n - 3]; // add values at two duplicated edges right away
for (int j = 1; j < n - 1; j++)
{
acc += _idftTable[k][j] * _bandSpectrum[j - 1];
}
_cc[k] = acc / (2 * (n - 1));
}
// LPC:
for (int k = 0; k < _lpc.Length; _lpc[k] = 0, k++)
{
;
}
float err = Lpc.LevinsonDurbin(_cc, _lpc, _lpcOrder);
// 7) compute LPCC coefficients from LPC
Lpc.ToCepstrum(_lpc, err, features);
// 8) (optional) liftering
if (_lifterCoeffs != null)
{
features.ApplyWindow(_lifterCoeffs);
}
// 9) (optional) replace first coeff with log(energy)
if (_includeEnergy)
{
features[0] = (float)Math.Log(Math.Max(block.Sum(x => x * x), _logEnergyFloor));
}
}
/// <summary>
/// Reset state
/// </summary>
public override void Reset()
{
if (_rastaFilters == null)
{
return;
}
foreach (RastaFilter filter in _rastaFilters)
{
filter.Reset();
}
}
/// <summary>
/// In case of RASTA filtering computations can't be done in parallel
/// </summary>
/// <returns></returns>
public override bool IsParallelizable()
{
return _rasta == 0;
}
/// <summary>
/// Copy of current extractor that can work in parallel
/// </summary>
/// <returns></returns>
public override FeatureExtractor ParallelCopy()
{
return new PlpExtractor(
new PlpOptions
{
SamplingRate = SamplingRate,
FeatureCount = FeatureCount,
FrameDuration = FrameDuration,
HopDuration = HopDuration,
LpcOrder = _lpcOrder,
Rasta = _rasta,
FilterBank = FilterBank,
FilterBankSize = FilterBank.Length,
FftSize = _blockSize,
LifterSize = _lifterSize,
PreEmphasis = _preEmphasis,
Window = _window,
CenterFrequencies = _centerFrequencies,
IncludeEnergy = _includeEnergy,
LogEnergyFloor = _logEnergyFloor
});
}
}
}
| 32.81 | 135 | 0.495504 | [
"Apache-2.0"
] | AIFramework/AIFrameworkOpen | AI/BackEnds/DSP/NWaves/FeatureExtractors/PlpExtractor.cs | 13,126 | C# |
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the medialive-2017-10-14.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Amazon.MediaLive.Model;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Transform;
using Amazon.Runtime.Internal.Util;
using ThirdParty.Json.LitJson;
namespace Amazon.MediaLive.Model.Internal.MarshallTransformations
{
/// <summary>
/// ListInputDevices Request Marshaller
/// </summary>
public class ListInputDevicesRequestMarshaller : IMarshaller<IRequest, ListInputDevicesRequest> , IMarshaller<IRequest,AmazonWebServiceRequest>
{
/// <summary>
/// Marshaller the request object to the HTTP request.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public IRequest Marshall(AmazonWebServiceRequest input)
{
return this.Marshall((ListInputDevicesRequest)input);
}
/// <summary>
/// Marshaller the request object to the HTTP request.
/// </summary>
/// <param name="publicRequest"></param>
/// <returns></returns>
public IRequest Marshall(ListInputDevicesRequest publicRequest)
{
IRequest request = new DefaultRequest(publicRequest, "Amazon.MediaLive");
request.Headers[Amazon.Util.HeaderKeys.XAmzApiVersion] = "2017-10-14";
request.HttpMethod = "GET";
if (publicRequest.IsSetMaxResults())
request.Parameters.Add("maxResults", StringUtils.FromInt(publicRequest.MaxResults));
if (publicRequest.IsSetNextToken())
request.Parameters.Add("nextToken", StringUtils.FromString(publicRequest.NextToken));
request.ResourcePath = "/prod/inputDevices";
request.MarshallerVersion = 2;
request.UseQueryString = true;
return request;
}
private static ListInputDevicesRequestMarshaller _instance = new ListInputDevicesRequestMarshaller();
internal static ListInputDevicesRequestMarshaller GetInstance()
{
return _instance;
}
/// <summary>
/// Gets the singleton.
/// </summary>
public static ListInputDevicesRequestMarshaller Instance
{
get
{
return _instance;
}
}
}
} | 34.456522 | 147 | 0.649842 | [
"Apache-2.0"
] | PureKrome/aws-sdk-net | sdk/src/Services/MediaLive/Generated/Model/Internal/MarshallTransformations/ListInputDevicesRequestMarshaller.cs | 3,170 | C# |
using System;
namespace FontAwesome
{
/// <summary>
/// The unicode values for all FontAwesome icons.
/// <para/>
/// See https://fontawesome.com/cheatsheet
/// <para/>
/// This code was automatically generated by FA2CS (https://github.com/michaelswells/fa2cs a modified fork from https://github.com/matthewrdev/fa2cs).
/// </summary>
public static partial class Unicode
{
/// <summary>
/// fa-comment-alt-medical unicode value ("\uf7f4").
/// <para/>
/// This icon supports the following styles: Light (Pro), Regular (Pro), Solid (Pro), Duotone (Pro)
/// <para/>
/// See https://fontawesome.com/icons/comment-alt-medical
/// </summary>
public const string CommentAltMedical = "\uf7f4";
}
/// <summary>
/// The Css values for all FontAwesome icons.
/// <para/>
/// See https://fontawesome.com/cheatsheet
/// <para/>
/// This code was automatically generated by FA2CS (https://github.com/michaelswells/fa2cs a modified fork from https://github.com/matthewrdev/fa2cs).
/// </summary>
public static partial class Css
{
/// <summary>
/// CommentAltMedical unicode value ("fa-comment-alt-medical").
/// <para/>
/// This icon supports the following styles: Light (Pro), Regular (Pro), Solid (Pro), Duotone (Pro)
/// <para/>
/// See https://fontawesome.com/icons/comment-alt-medical
/// </summary>
public const string CommentAltMedical = "fa-comment-alt-medical";
}
/// <summary>
/// The Icon names for all FontAwesome icons.
/// <para/>
/// See https://fontawesome.com/cheatsheet
/// <para/>
/// This code was automatically generated by FA2CS (https://github.com/michaelswells/fa2cs a modified fork from https://github.com/matthewrdev/fa2cs).
/// </summary>
public static partial class Icon
{
/// <summary>
/// fa-comment-alt-medical unicode value ("\uf7f4").
/// <para/>
/// This icon supports the following styles: Light (Pro), Regular (Pro), Solid (Pro), Duotone (Pro)
/// <para/>
/// See https://fontawesome.com/icons/comment-alt-medical
/// </summary>
public const string CommentAltMedical = "CommentAltMedical";
}
} | 38.196721 | 154 | 0.606438 | [
"MIT"
] | michaelswells/FontAwesomeAttribute | FontAwesome/FontAwesome.CommentAltMedical.cs | 2,330 | C# |
using System.Configuration;
namespace RemoteAgent.Service.Configuration
{
public class ClosableProcessSettings : ConfigurationElement
{
[ConfigurationProperty("namePattern")]
public string NamePattern
{
get => base["namePattern"] as string;
set => base["namePattern"] = value;
}
}
} | 21.5 | 60 | 0.737542 | [
"Apache-2.0"
] | taori/PCRemoteController | src/RemoteAgent.Service/RemoteAgent.Service/Configuration/ClosableProcessSettings.cs | 303 | C# |
using GraphQL.Types;
using NetGraphQL.Shared;
namespace NetGraphQL.GraphQL.Types.Response
{
public class AddNewUserResponseType : ObjectGraphType<ServiceResponse<int>>
{
public AddNewUserResponseType()
{
Name = nameof(AddNewUserResponseType);
Field(f => f.Messages);
Field(f => f.ErrorMessages);
Field(f => f.Result);
Field(f => f.IsError);
}
}
}
| 23.473684 | 79 | 0.59417 | [
"MIT"
] | bayupuspanugraha/netgraphql | src/NetGraphQL.GraphQL/Types/Response/AddNewUserResponseType.cs | 448 | C# |
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
#nullable enable
#pragma warning disable CS1591
#pragma warning disable CS0108
#pragma warning disable 618
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Runtime.Serialization;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;
using JetBrains.Space.Common;
using JetBrains.Space.Common.Json.Serialization;
using JetBrains.Space.Common.Json.Serialization.Polymorphism;
using JetBrains.Space.Common.Types;
namespace JetBrains.Space.Client
{
[JsonConverter(typeof(ClassNameDtoTypeConverter))]
public class CodeDiscussionSnippet
: IClassNameConvertible, IPropagatePropertyAccessPath
{
[JsonPropertyName("className")]
public virtual string? ClassName => "CodeDiscussionSnippet";
public static CodeDiscussionSnippetInlineDiffSnippet InlineDiffSnippet(List<InlineDiffLine> lines)
=> new CodeDiscussionSnippetInlineDiffSnippet(lines: lines);
public static CodeDiscussionSnippetPlainSnippet PlainSnippet(List<CodeLine> lines)
=> new CodeDiscussionSnippetPlainSnippet(lines: lines);
public CodeDiscussionSnippet() { }
public virtual void SetAccessPath(string path, bool validateHasBeenSet)
{
}
}
}
| 33.259259 | 106 | 0.672606 | [
"Apache-2.0"
] | PatrickRatzow/space-dotnet-sdk | src/JetBrains.Space.Client/Generated/Dtos/CodeDiscussionSnippet.generated.cs | 1,796 | C# |
namespace Atlas.Core.Objects.Update
{
public enum TimeStep
{
None,
Fixed,
Variable
}
} | 10.666667 | 36 | 0.6875 | [
"MIT"
] | RSGMercenary/Atlas | Core/Objects/Update/TimeStep.cs | 98 | C# |
namespace Smellyriver.TankInspector.Pro.Modularity.Input
{
public interface IRepositoryCommand : ICommand
{
}
}
| 17.857143 | 57 | 0.736 | [
"MIT"
] | smellyriver/tank-inspector-pro | src/Smellyriver.TankInspector.Pro/Modularity/Input/IRepositoryCommand.cs | 127 | C# |
using Unity.Burst;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Transforms;
using Unity.Collections;
using Unity.Rendering;
using UnityEngine;
/*
/// <summary>
/// update Live from NextState and add ChangedTag
/// </summary>
[AlwaysSynchronizeSystem]
[UpdateBefore(typeof(UpdateNextSateSystem))]
//[UpdateBefore(typeof(UpdateMarkChangeSystem))]
public class GenerateNextStateSystem : JobComponentSystem {
// For Burst or Schedule (worker thread) jobs to access data outside the a job an explicit struct with a
// read only variable is needed
[BurstCompile]
struct SetLive : IJobForEach<NextState, Live, Neighbors> {
// liveLookup is a pointer to a native array of live components indexed by entity
// since allows access outside set of entities being handled a single job o thread that is running
// concurrently with other threads accessing the same native array it must be marked read only
[ReadOnly]public ComponentDataFromEntity<Live> liveLookup;
public void Execute(ref NextState nextState, [ReadOnly] ref Live live,[ReadOnly] ref Neighbors neighbors){
int numLiveNeighbors = 0;
numLiveNeighbors += liveLookup[neighbors.nw].value;
numLiveNeighbors += liveLookup[neighbors.n].value;
numLiveNeighbors += liveLookup[neighbors.ne].value;
numLiveNeighbors += liveLookup[neighbors.w].value;
numLiveNeighbors += liveLookup[neighbors.e].value;
numLiveNeighbors += liveLookup[neighbors.sw].value;
numLiveNeighbors += liveLookup[neighbors.s].value;
numLiveNeighbors += liveLookup[neighbors.se].value;
//Note math.Select(falseValue, trueValue, boolSelector)
// did not want to pass in arrays so change to
// 3 selects
int bornValue = math.select(0, 1, numLiveNeighbors == 3);
int stayValue = math.select(0, 1, numLiveNeighbors == 2);
stayValue = math.select(stayValue, 1, numLiveNeighbors == 3);
nextState.value = math.select( bornValue,stayValue, live.value== 1);
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps) {
// make a native array of live components indexed by entity
ComponentDataFromEntity<Live> statuses = GetComponentDataFromEntity<Live>();
SetLive neighborCounterJob = new SetLive() {
liveLookup = statuses,
};
JobHandle jobHandle = neighborCounterJob.Schedule(this, inputDeps);
return jobHandle;
}
}
[UpdateBefore(typeof(UpdateSuperCellIndexSystem))]
[AlwaysSynchronizeSystem]
[BurstCompile]
public class UpdateNextSateSystem : JobComponentSystem {
protected override JobHandle OnUpdate(JobHandle inputDeps) {
JobHandle jobHandle = Entities
.ForEach((Entity entity, int entityInQueryIndex, ref Live live, in NextState nextState)=> {
live.value = nextState.value;
}).Schedule( inputDeps);
return jobHandle;
}
}
*/
/*
[AlwaysSynchronizeSystem]
[BurstCompile]
public class UpdateMarkChangeSystem : JobComponentSystem {
protected EndSimulationEntityCommandBufferSystem m_EndSimulationEcbSystem;
protected override void OnCreate() {
base.OnCreate();
// Find the ECB system once and store it for later usage
m_EndSimulationEcbSystem = World
.GetOrCreateSystem<EndSimulationEntityCommandBufferSystem>();
}
protected override JobHandle OnUpdate(JobHandle inputDeps) {
var ecb = m_EndSimulationEcbSystem.CreateCommandBuffer().ToConcurrent();
JobHandle jobHandle = Entities
.ForEach((Entity entity, int entityInQueryIndex, ref Live live, in NextState nextState)=> {
if (live.value != nextState.value) {
ecb.AddComponent<ChangedTag>(entityInQueryIndex, entity);
}
live.value = nextState.value;
}).Schedule( inputDeps);
m_EndSimulationEcbSystem.AddJobHandleForProducer(jobHandle);
return jobHandle;
}
}
/// <summary>
/// set location on cells marked as changed and remove ChangedTag
/// </summary>
// .WithAll<ChangedTag>() limits changes to only meshes whose lives status changed
[UpdateInGroup(typeof(PresentationSystemGroup))]
[AlwaysSynchronizeSystem]
public class UpdateDisplayChangedSystem : JobComponentSystem {
protected override JobHandle OnUpdate(JobHandle inputDeps) {
Entities
.WithoutBurst()
.WithAll<ChangedTag>()
.ForEach((Entity entity, int entityInQueryIndex, in Live live, in PosXY posXY) => {
ECSGrid.ShowCell(posXY.pos, live.value ==1);
}).Run();
return inputDeps;
}
}
[UpdateInGroup(typeof(PresentationSystemGroup))]
[AlwaysSynchronizeSystem]
//[UpdateAfter(typeof(UpdateDisplayChangedSystem))]
[BurstCompile]
public class UpdateClearChangedSystem : JobComponentSystem {
// I would like to do this in EndPresentationEntityCommandBufferSystem
// but it does not exist
protected BeginSimulationEntityCommandBufferSystem m_BeginSimulationEcbSystem;
protected override void OnCreate() {
base.OnCreate();
// Find the ECB system once and store it for later usage
m_BeginSimulationEcbSystem = World
.GetOrCreateSystem<BeginSimulationEntityCommandBufferSystem>();
}
protected override JobHandle OnUpdate(JobHandle inputDeps) {
var ecb = m_BeginSimulationEcbSystem.CreateCommandBuffer().ToConcurrent();
var jobHandle =
Entities
.WithAll<ChangedTag>()
.ForEach((Entity entity, int entityInQueryIndex) => {
ecb.RemoveComponent<ChangedTag>(entityInQueryIndex, entity);
}).Schedule(inputDeps);
m_BeginSimulationEcbSystem.AddJobHandleForProducer(jobHandle);
return jobHandle;
}
}
*/
/*
[AlwaysSynchronizeSystem]
[BurstCompile]
public class UpdateSuperCellIndexSystem : JobComponentSystem {
EntityQuery m_Group;
protected override void OnCreate() {
// Cached access to a set of ComponentData based on a specific query
m_Group = GetEntityQuery(
ComponentType.ReadOnly<Live>(),
ComponentType.ReadOnly<SubcellIndex>(),
ComponentType.ReadOnly<PosXY>(),
ComponentType.ChunkComponent<SuperCellLives>()
);
}
struct SuperCellIndexJob : IJobChunk {
[ReadOnly]public ArchetypeChunkComponentType<Live> LiveType;
[ReadOnly]public ArchetypeChunkComponentType<SubcellIndex> SubcellIndexType;
[ReadOnly]public ArchetypeChunkComponentType<PosXY> PosXYType;
public ArchetypeChunkComponentType<SuperCellLives> SuperCellLivesType;
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) {
var lives = chunk.GetNativeArray(LiveType);
var SubcellIndices = chunk.GetNativeArray(SubcellIndexType);
var posXYs = chunk.GetNativeArray(PosXYType);
var scLives = new int4();
for (var i = 0; i < chunk.Count; i++) {
scLives[SubcellIndices[i].index] = lives[i].value;
}
int index = 0;
for (int i = 0; i < 4; i++) {
index += scLives[i]<< i;
}
var pos = new int2();
pos[0] = (posXYs[0].pos.x / 2) * 2; //(0,1) -> 0, (2,3) -> 2, etc.
pos[1] = (posXYs[0].pos.y / 2) * 2;
var chunkData = chunk.GetChunkComponentData(SuperCellLivesType);
bool changed = index != chunkData.index;
chunk.SetChunkComponentData(SuperCellLivesType,
new SuperCellLives() {
index = index,
changed = changed,
pos = pos
});
}
}
protected override JobHandle OnUpdate(JobHandle inputDependencies) {
var LiveType = GetArchetypeChunkComponentType<Live>(true);
var SubcellIndexType = GetArchetypeChunkComponentType<SubcellIndex>(false);
var SuperCellLivesType = GetArchetypeChunkComponentType<SuperCellLives>();
var PosXYType = GetArchetypeChunkComponentType<PosXY>();
var job = new SuperCellIndexJob() {
SubcellIndexType = SubcellIndexType,
LiveType = LiveType,
SuperCellLivesType = SuperCellLivesType,
PosXYType = PosXYType
};
return job.Schedule(m_Group, inputDependencies);
}
}
[AlwaysSynchronizeSystem]
[UpdateAfter(typeof(UpdateSuperCellIndexSystem))]
public class UpdateSuperCellChangedSystem : JobComponentSystem {
EntityQuery m_Group;
protected override void OnCreate() {
// Cached access to a set of ComponentData based on a specific query
m_Group = GetEntityQuery(
ComponentType.ChunkComponentReadOnly<SuperCellLives>()
);
}
struct SuperCellDisplayJob : IJobChunk {
public ArchetypeChunkComponentType<SuperCellLives> SuperCellLivesType;
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) {
var chunkData = chunk.GetChunkComponentData(SuperCellLivesType);
if (chunkData.changed) {
ECSGridSuperCell.ShowSuperCell(chunkData.pos, chunkData.index);
}
}
}
protected override JobHandle OnUpdate(JobHandle inputDependencies) {
var SuperCellLivesType = GetArchetypeChunkComponentType<SuperCellLives>();
var job = new SuperCellDisplayJob() {
SuperCellLivesType = SuperCellLivesType
};
job.Run(m_Group);
return default;
}
}
*/
/*
/// <summary>
/// Copies ChunkComponent to instance component so it can checked in debugger
/// </summary>
[AlwaysSynchronizeSystem]
[BurstCompile]
public class UpdateDebugSuperCellLivesSystem : JobComponentSystem {
EntityQuery m_Group;
protected override void OnCreate() {
// Cached access to a set of ComponentData based on a specific query
m_Group = GetEntityQuery(ComponentType.ReadWrite<DebugSuperCellLives>(),
ComponentType.ChunkComponent<SuperCellLives>()
);
}
struct DebugSuperCellLivesJob : IJobChunk {
public ArchetypeChunkComponentType<DebugSuperCellLives> DebugSuperCellLivesType;
public ArchetypeChunkComponentType<SuperCellLives> SuperCellLivesType;
[ReadOnly] public ArchetypeChunkSharedComponentType<SuperCellXY> superCellSharedType;
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) {
var debugSuperCellLives = chunk.GetNativeArray(DebugSuperCellLivesType);
int sharedComponentIndex = chunk.GetSharedComponentIndex(superCellSharedType);
int numSc = chunk.NumSharedComponents();
//var x = chunk.GetSharedComponentData()
var chunkData = chunk.GetChunkComponentData(SuperCellLivesType);
//int uniqueIndex = chunkData.indices.IndexOf(sharedComponentIndex);
//chunk.GetSharedComponentData<SuperCellXY>()
for (var i = 0; i < chunk.Count; i++) {
int4 livesDecoded = new int4();
int encoded = chunkData.index;
for (int j = 0; j < 4; j++) {
livesDecoded[j] = encoded % 2;
encoded >>= 1;
}
debugSuperCellLives[i] = new DebugSuperCellLives() {
index = chunkData.index,
livesDecoded = livesDecoded,
changed = chunkData.changed,
pos = chunkData.pos
};
}
}
}
protected override JobHandle OnUpdate(JobHandle inputDependencies) {
var DebugSuperCellLivesType = GetArchetypeChunkComponentType<DebugSuperCellLives>();
var SuperCellLivesType = GetArchetypeChunkComponentType<SuperCellLives>();
var SuperCellXYType = GetArchetypeChunkSharedComponentType<SuperCellXY>();
var job = new DebugSuperCellLivesJob() {
DebugSuperCellLivesType = DebugSuperCellLivesType,
SuperCellLivesType = SuperCellLivesType,
superCellSharedType = SuperCellXYType
};
return job.Schedule(m_Group, inputDependencies);
}
}
*/
| 37.296188 | 115 | 0.648687 | [
"MIT"
] | ryuuguu/Unity-ECS-Life | Assets/Life/ECSLife/Stashed T4 stuff/GridSystemsT4.cs | 12,720 | C# |
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the comprehendmedical-2018-10-30.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Amazon.ComprehendMedical.Model;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Transform;
using Amazon.Runtime.Internal.Util;
using ThirdParty.Json.LitJson;
namespace Amazon.ComprehendMedical.Model.Internal.MarshallTransformations
{
/// <summary>
/// DetectEntitiesV2 Request Marshaller
/// </summary>
public class DetectEntitiesV2RequestMarshaller : IMarshaller<IRequest, DetectEntitiesV2Request> , IMarshaller<IRequest,AmazonWebServiceRequest>
{
/// <summary>
/// Marshaller the request object to the HTTP request.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public IRequest Marshall(AmazonWebServiceRequest input)
{
return this.Marshall((DetectEntitiesV2Request)input);
}
/// <summary>
/// Marshaller the request object to the HTTP request.
/// </summary>
/// <param name="publicRequest"></param>
/// <returns></returns>
public IRequest Marshall(DetectEntitiesV2Request publicRequest)
{
IRequest request = new DefaultRequest(publicRequest, "Amazon.ComprehendMedical");
string target = "ComprehendMedical_20181030.DetectEntitiesV2";
request.Headers["X-Amz-Target"] = target;
request.Headers["Content-Type"] = "application/x-amz-json-1.1";
request.Headers[Amazon.Util.HeaderKeys.XAmzApiVersion] = "2018-10-30";
request.HttpMethod = "POST";
request.ResourcePath = "/";
request.MarshallerVersion = 2;
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
JsonWriter writer = new JsonWriter(stringWriter);
writer.WriteObjectStart();
var context = new JsonMarshallerContext(request, writer);
if(publicRequest.IsSetText())
{
context.Writer.WritePropertyName("Text");
context.Writer.Write(publicRequest.Text);
}
writer.WriteObjectEnd();
string snippet = stringWriter.ToString();
request.Content = System.Text.Encoding.UTF8.GetBytes(snippet);
}
return request;
}
private static DetectEntitiesV2RequestMarshaller _instance = new DetectEntitiesV2RequestMarshaller();
internal static DetectEntitiesV2RequestMarshaller GetInstance()
{
return _instance;
}
/// <summary>
/// Gets the singleton.
/// </summary>
public static DetectEntitiesV2RequestMarshaller Instance
{
get
{
return _instance;
}
}
}
} | 36.447619 | 148 | 0.616148 | [
"Apache-2.0"
] | philasmar/aws-sdk-net | sdk/src/Services/ComprehendMedical/Generated/Model/Internal/MarshallTransformations/DetectEntitiesV2RequestMarshaller.cs | 3,827 | C# |
using FluentAssertions;
using SlipeServer.Packets.Builder;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using Xunit;
namespace SlipeServer.Packets.Tests;
public class PacketBuilderTests
{
[Fact]
public void WriteIntTest()
{
var builder = new PacketBuilder();
builder.Write(4096);
var bytes = builder.Build();
bytes.Should().Equal(new byte[]
{
0, 0x10, 0, 0
});
}
[Theory]
[InlineData(0.50f, new byte[] { 0b00000000, 0b00000000, 0b00000000, 0b00111111 })]
[InlineData(128.56f, new byte[] { 0b01011100, 0b10001111, 0b00000000, 0b01000011 })]
public void WriteFloatTest(float input, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.Write(input);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(0x00, new byte[] { 0xf0 })]
[InlineData(0x10, new byte[] { 0xe1, 0x00 })]
[InlineData(0x1000, new byte[] { 0xC0, 0x02, 0x00 })]
[InlineData(0x100000, new byte[] { 0x80, 0x00, 0x04, 0x00 })]
[InlineData(0x10000000, new byte[] { 0x00, 0x00, 0x00, 0x08, 0x00 })]
[InlineData(0xfedcbafe, new byte[] { 0x7F, 0x5D, 0x6E, 0x7F, 0x00 })]
[InlineData(0xfedcbaab, new byte[] { 0x55, 0xDD, 0x6E, 0x7F, 0x00 })]
public void WriteCompressedUintTest(uint value, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteCompressed(value);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(1235, new byte[] { 0b11011010, 0b01100000, 0b10000000 })]
[InlineData(0, new byte[] { 0b11110000 })]
public void WriteCompressedUlongTest(ulong value, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteCompressed(value);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(9, new byte[] { 0b111001_00 })]
public void WriteCompressedUshortTest(ushort value, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteCompressed(value);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(0.56f, new byte[] { 0b10101101, 0b11000111 })]
public void WriteCompressedFloatTest(float value, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteCompressed(value);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(new byte[] { 0b10100011 }, 4, new byte[] { 0b00110000 })]
[InlineData(new byte[] { 0b11111111, 0b10100011 }, 12, new byte[] { 0b11111111, 0b00110000 })]
public void WriteCappedTest(byte[] input, int bits, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteBytesCapped(input, bits);
builder.Length.Should().Be(bits);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(0xCAF, 12, new byte[] { 0b10101111, 0b11000000 })]
[InlineData(0xe38, 12, new byte[] { 0b00111000, 0b11100000 })]
public void WriteCappedUint16Test(ushort input, int bits, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteCapped(input, bits);
builder.Length.Should().Be(bits);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(0.5, 12, -3.14159f, 3.14159f, false, new byte[] { 0b01000101, 0b10010000 })]
[InlineData(0.5, 16, -3.14159f, 3.14159f, false, new byte[] { 0b01011111, 0b10010100 })]
[InlineData(128.573, 16, 0, 360, false, new byte[] { 0b01101110, 0b01011011 })]
public void WriteFloatFromBitsTest(float input, int bitCount, float min, float max, bool preserve, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteFloatFromBits(input, bitCount, min, max, preserve);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(0.5, 0.5, 0.5, new byte[] { 0b00111111, 0b11101111, 0b11011111, 0b11110111, 0b11100000 })]
public void WriteNormalizedVectorTest(float x, float y, float z, byte[] expectedOutput)
{
var builder = new PacketBuilder();
builder.WriteNormalizedVector(new Vector3(x, y, z));
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Theory]
[InlineData(255, 255, 255, 255, false, false, new byte[] { 0xFF, 0xFF, 0xFF })]
[InlineData(0, 255, 255, 255, false, false, new byte[] { 0xFF, 0xFF, 0xFF })]
[InlineData(128, 255, 255, 255, true, true, new byte[] { 0x80, 0xFF, 0xFF, 0xFF })]
[InlineData(128, 255, 255, 255, true, false, new byte[] { 0xFF, 0xFF, 0xFF, 0x80 })]
public void WriteColorTest(byte alpha, byte red, byte green, byte blue, bool withAlpha, bool alphaFirst, byte[] expectedOutput)
{
var builder = new PacketBuilder();
Color color = Color.FromArgb(alpha, red, green, blue);
builder.Write(color, withAlpha, alphaFirst);
var bytes = builder.Build();
bytes.Should().Equal(expectedOutput);
}
[Fact]
public void AlignToByteBoundaryTest()
{
var builder = new PacketBuilder();
builder.Write(true);
builder.AlignToByteBoundary();
builder.Write(true);
builder.AlignToByteBoundary();
builder.Write(true);
var bytes = builder.Build();
bytes.Length.Should().Be(3);
bytes.Should().Equal(new byte[] { 0b10000000, 0b10000000, 0b10000000 });
}
}
| 31.673797 | 131 | 0.633463 | [
"MIT"
] | correaAlex/Slipe-Server | SlipeServer.Packets.Tests/PacketBuilderTests.cs | 5,925 | C# |
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.Web.UI.DataVisualization.Charting;
using MOE.Common.Models;
namespace MOE.Common.Business
{
public class LinkPivotPair
{
public LinkPivotPair(Approach signalApproach, Approach downSignalApproach, DateTime startDate, DateTime endDate,
int cycleTime, double bias, string biasDirection, List<DateTime> dates, int linkNumber)
{
SignalApproach = signalApproach;
DownSignalApproach = downSignalApproach;
StartDate = startDate;
LinkNumber = linkNumber;
SetPcds(endDate, dates, cycleTime);
//Check to see if both directions have detection if so analyze both
if (UpstreamPcd.Count > 0 && DownstreamPcd.Count > 0)
if (bias != 0)
GetBiasedLinkPivot(cycleTime, bias, biasDirection, dates);
//If no bias is provided
else
GetUnbiasedLinkPivot(cycleTime, dates);
//If only upstream has detection do analysis for upstream only
else if (DownstreamPcd.Count == 0 && UpstreamPcd.Count > 0)
if (bias != 0)
{
double upstreamBias = 1;
double downstreamBias = 1;
if (biasDirection == "Downstream")
downstreamBias = 1 + bias / 100;
else
upstreamBias = 1 + bias / 100;
//set the original values to compare against
var maxBiasArrivalOnGreen = AogDownstreamBefore * downstreamBias +
AogUpstreamBefore * upstreamBias;
MaxArrivalOnGreen = AogUpstreamBefore;
//Add the total to the results grid
ResultsGraph.Add(0, MaxArrivalOnGreen);
UpstreamResultsGraph.Add(0, AogUpstreamBefore * upstreamBias);
DownstreamResultsGraph.Add(0, AogDownstreamBefore * downstreamBias);
AogUpstreamPredicted = AogUpstreamBefore;
PaogUpstreamPredicted = Math.Round(AogUpstreamBefore / TotalVolumeUpstream, 2) * 100;
SecondsAdded = 0;
for (var i = 1; i <= cycleTime; i++)
{
double totalBiasArrivalOnGreen = 0;
double totalArrivalOnGreen = 0;
double totalUpstreamAog = 0;
for (var index = 0; index < dates.Count; index++)
{
UpstreamPcd[index].LinkPivotAddSeconds(-1);
totalBiasArrivalOnGreen += UpstreamPcd[index].TotalArrivalOnGreen * upstreamBias;
totalArrivalOnGreen += UpstreamPcd[index].TotalArrivalOnGreen;
totalUpstreamAog += UpstreamPcd[index].TotalArrivalOnGreen;
}
//Add the total aog to the dictionary
ResultsGraph.Add(i, totalBiasArrivalOnGreen);
UpstreamResultsGraph.Add(i, totalUpstreamAog);
if (totalBiasArrivalOnGreen > maxBiasArrivalOnGreen)
{
maxBiasArrivalOnGreen = totalBiasArrivalOnGreen;
MaxArrivalOnGreen = totalArrivalOnGreen;
AogUpstreamPredicted = totalUpstreamAog;
PaogUpstreamPredicted = Math.Round(totalUpstreamAog / TotalVolumeUpstream, 2) * 100;
SecondsAdded = i;
}
}
//Get the link totals
AogTotalPredicted = MaxArrivalOnGreen;
PaogTotalPredicted = PaogUpstreamPredicted;
}
//No bias provided
else
{
//set the original values to compare against
AogTotalBefore = AogDownstreamBefore + AogUpstreamBefore;
MaxArrivalOnGreen = AogUpstreamBefore;
PaogTotalBefore = Math.Round(AogTotalBefore / (TotalVolumeDownstream + TotalVolumeUpstream), 2) *
100;
//Add the total aog to the dictionary
ResultsGraph.Add(0, MaxArrivalOnGreen);
UpstreamResultsGraph.Add(0, AogUpstreamBefore);
DownstreamResultsGraph.Add(0, AogDownstreamBefore);
AogUpstreamPredicted = AogUpstreamBefore;
PaogUpstreamPredicted = Math.Round(AogUpstreamBefore / TotalVolumeUpstream, 2) * 100;
SecondsAdded = 0;
for (var i = 1; i <= cycleTime; i++)
{
double totalArrivalOnGreen = 0;
double totalUpstreamAog = 0;
for (var index = 0; index < dates.Count; index++)
{
UpstreamPcd[index].LinkPivotAddSeconds(-1);
totalArrivalOnGreen += UpstreamPcd[index].TotalArrivalOnGreen;
totalUpstreamAog += UpstreamPcd[index].TotalArrivalOnGreen;
}
//Add the total aog to the dictionary
ResultsGraph.Add(i, totalArrivalOnGreen);
UpstreamResultsGraph.Add(i, totalUpstreamAog);
if (totalArrivalOnGreen > MaxArrivalOnGreen)
{
MaxArrivalOnGreen = totalArrivalOnGreen;
AogUpstreamPredicted = totalUpstreamAog;
PaogUpstreamPredicted = Math.Round(totalUpstreamAog / TotalVolumeUpstream, 2) * 100;
SecondsAdded = i;
}
//Get the link totals
AogTotalPredicted = MaxArrivalOnGreen;
PaogTotalPredicted = PaogUpstreamPredicted;
}
}
//If downsteam only has detection
else if (UpstreamPcd.Count == 0 && DownstreamPcd.Count > 0)
if (bias != 0)
{
double upstreamBias = 1;
double downstreamBias = 1;
if (biasDirection == "Downstream")
downstreamBias = 1 + bias / 100;
else
upstreamBias = 1 + bias / 100;
//set the original values to compare against
var maxBiasArrivalOnGreen = AogDownstreamBefore * downstreamBias;
MaxArrivalOnGreen = AogDownstreamBefore + AogUpstreamBefore;
//Add the total aog to the dictionary
ResultsGraph.Add(0, MaxArrivalOnGreen);
DownstreamResultsGraph.Add(0, AogDownstreamBefore * downstreamBias);
AogDownstreamPredicted = AogDownstreamBefore;
PaogDownstreamPredicted = Math.Round(AogDownstreamBefore / TotalVolumeDownstream, 2) * 100;
SecondsAdded = 0;
for (var i = 1; i <= cycleTime; i++)
{
double totalBiasArrivalOnGreen = 0;
double totalArrivalOnGreen = 0;
double totalDownstreamAog = 0;
for (var index = 0; index < dates.Count; index++)
{
DownstreamPcd[index].LinkPivotAddSeconds(1);
totalBiasArrivalOnGreen += DownstreamPcd[index].TotalArrivalOnGreen * downstreamBias;
totalArrivalOnGreen += DownstreamPcd[index].TotalArrivalOnGreen;
totalDownstreamAog += DownstreamPcd[index].TotalArrivalOnGreen;
}
//Add the total aog to the dictionary
ResultsGraph.Add(i, totalBiasArrivalOnGreen);
DownstreamResultsGraph.Add(i, totalDownstreamAog);
if (totalBiasArrivalOnGreen > maxBiasArrivalOnGreen)
{
maxBiasArrivalOnGreen = totalBiasArrivalOnGreen;
MaxArrivalOnGreen = totalArrivalOnGreen;
AogDownstreamPredicted = totalDownstreamAog;
PaogDownstreamPredicted = Math.Round(totalDownstreamAog / TotalVolumeDownstream, 2) * 100;
SecondsAdded = i;
}
}
//Get the link totals
AogTotalPredicted = MaxArrivalOnGreen;
PaogTotalPredicted = PaogDownstreamPredicted;
}
//if no bias was provided
else
{
//set the original values to compare against
MaxArrivalOnGreen = AogDownstreamBefore;
//Add the total aog to the dictionary
ResultsGraph.Add(0, MaxArrivalOnGreen);
DownstreamResultsGraph.Add(0, AogDownstreamBefore);
AogDownstreamPredicted = AogDownstreamBefore;
PaogDownstreamPredicted = Math.Round(AogDownstreamBefore / TotalVolumeDownstream, 2) * 100;
SecondsAdded = 0;
for (var i = 1; i <= cycleTime; i++)
{
double totalArrivalOnGreen = 0;
double totalDownstreamAog = 0;
for (var index = 0; index < dates.Count; index++)
{
DownstreamPcd[index].LinkPivotAddSeconds(1);
totalArrivalOnGreen += DownstreamPcd[index].TotalArrivalOnGreen;
totalDownstreamAog += DownstreamPcd[index].TotalArrivalOnGreen;
}
//Add the total aog to the dictionary
ResultsGraph.Add(i, totalArrivalOnGreen);
DownstreamResultsGraph.Add(i, totalDownstreamAog);
if (totalArrivalOnGreen > MaxArrivalOnGreen)
{
MaxArrivalOnGreen = totalArrivalOnGreen;
AogDownstreamPredicted = totalDownstreamAog;
PaogDownstreamPredicted = Math.Round(totalDownstreamAog / TotalVolumeDownstream, 2) * 100;
SecondsAdded = i;
}
}
//Get the link totals
AogTotalPredicted = MaxArrivalOnGreen;
PaogTotalPredicted = PaogDownstreamPredicted;
}
GetNewResultsChart();
}
public double SecondsAdded { get; set; }
public double MaxArrivalOnGreen { get; set; }
public double MaxPercentAog { get; set; }
public List<SignalPhase> UpstreamPcd { get; } = new List<SignalPhase>();
public List<SignalPhase> DownstreamPcd { get; } = new List<SignalPhase>();
public double PaogUpstreamBefore { get; set; } = 0;
public double PaogDownstreamBefore { get; set; }
public double PaogDownstreamPredicted { get; set; }
public double PaogUpstreamPredicted { get; set; }
public double AogUpstreamBefore { get; set; }
public double AogDownstreamBefore { get; set; }
public double AogDownstreamPredicted { get; set; }
public double AogUpstreamPredicted { get; set; }
public double TotalVolumeUpstream { get; set; }
public double TotalVolumeDownstream { get; set; }
public string ResultChartLocation { get; private set; }
public Dictionary<int, double> ResultsGraph { get; } = new Dictionary<int, double>();
public Dictionary<int, double> UpstreamResultsGraph { get; } = new Dictionary<int, double>();
public Dictionary<int, double> DownstreamResultsGraph { get; } = new Dictionary<int, double>();
public List<LinkPivotPCDDisplay> Display { get; } = new List<LinkPivotPCDDisplay>();
public double AogTotalBefore { get; set; }
public double PaogTotalBefore { get; set; }
public double AogTotalPredicted { get; set; }
public double PaogTotalPredicted { get; set; }
public Approach SignalApproach { get; }
public Approach DownSignalApproach { get; }
public DateTime StartDate { get; }
public int LinkNumber { get; set; }
private void GetUnbiasedLinkPivot(int cycleTime, List<DateTime> dates)
{
//set the original values to compare against
AogTotalBefore = AogDownstreamBefore + AogUpstreamBefore;
MaxArrivalOnGreen = AogTotalBefore;
PaogTotalBefore = Math.Round(AogTotalBefore / (TotalVolumeDownstream + TotalVolumeUpstream), 2) * 100;
//add the total to the results grid
ResultsGraph.Add(0, MaxArrivalOnGreen);
UpstreamResultsGraph.Add(0, AogUpstreamBefore);
DownstreamResultsGraph.Add(0, AogDownstreamBefore);
AogUpstreamPredicted = AogUpstreamBefore;
AogDownstreamPredicted = AogDownstreamBefore;
PaogDownstreamPredicted = Math.Round(AogDownstreamBefore / TotalVolumeDownstream, 2) * 100;
PaogUpstreamPredicted = Math.Round(AogUpstreamBefore / TotalVolumeUpstream, 2) * 100;
SecondsAdded = 0;
for (var i = 1; i <= cycleTime; i++)
{
double totalArrivalOnGreen = 0;
double totalUpstreamAog = 0;
double totalDownstreamAog = 0;
for (var index = 0; index < dates.Count; index++)
{
UpstreamPcd[index].LinkPivotAddSeconds(-1);
DownstreamPcd[index].LinkPivotAddSeconds(1);
totalArrivalOnGreen += UpstreamPcd[index].TotalArrivalOnGreen +
DownstreamPcd[index].TotalArrivalOnGreen;
totalUpstreamAog += UpstreamPcd[index].TotalArrivalOnGreen;
totalDownstreamAog += DownstreamPcd[index].TotalArrivalOnGreen;
}
//Add the total aog to the dictionary
ResultsGraph.Add(i, totalArrivalOnGreen);
UpstreamResultsGraph.Add(i, totalUpstreamAog);
DownstreamResultsGraph.Add(i, totalDownstreamAog);
if (totalArrivalOnGreen > MaxArrivalOnGreen)
{
MaxArrivalOnGreen = totalArrivalOnGreen;
AogUpstreamPredicted = totalUpstreamAog;
AogDownstreamPredicted = totalDownstreamAog;
PaogDownstreamPredicted = Math.Round(totalDownstreamAog / TotalVolumeDownstream, 2) * 100;
PaogUpstreamPredicted = Math.Round(totalUpstreamAog / TotalVolumeUpstream, 2) * 100;
SecondsAdded = i;
}
}
//Get the link totals
AogTotalPredicted = MaxArrivalOnGreen;
PaogTotalPredicted = Math.Round(AogTotalPredicted / (TotalVolumeUpstream + TotalVolumeDownstream), 2) * 100;
}
private void GetBiasedLinkPivot(int cycleTime, double bias, string biasDirection, List<DateTime> dates)
{
double upstreamBias = 1;
double downstreamBias = 1;
if (biasDirection == "Downstream")
downstreamBias = 1 + bias / 100;
else
upstreamBias = 1 + bias / 100;
//set the original values to compare against
AogTotalBefore = AogDownstreamBefore * downstreamBias +
AogUpstreamBefore * upstreamBias;
PaogTotalBefore =
Math.Round(
AogTotalBefore / (TotalVolumeDownstream * downstreamBias + TotalVolumeUpstream * upstreamBias), 2) *
100;
var maxBiasArrivalOnGreen = AogTotalBefore;
MaxArrivalOnGreen = AogDownstreamBefore + AogUpstreamBefore;
//add the total to the results grid
ResultsGraph.Add(0, MaxArrivalOnGreen);
UpstreamResultsGraph.Add(0, AogUpstreamBefore * upstreamBias);
DownstreamResultsGraph.Add(0, AogDownstreamBefore * downstreamBias);
AogUpstreamPredicted = AogUpstreamBefore;
AogDownstreamPredicted = AogDownstreamBefore;
PaogDownstreamPredicted = Math.Round(AogDownstreamBefore / TotalVolumeDownstream, 2) * 100;
PaogUpstreamPredicted = Math.Round(AogUpstreamBefore / TotalVolumeUpstream, 2) * 100;
SecondsAdded = 0;
for (var i = 1; i <= cycleTime; i++)
{
double totalBiasArrivalOnGreen = 0;
double totalArrivalOnGreen = 0;
double totalUpstreamAog = 0;
double totalDownstreamAog = 0;
for (var index = 0; index < dates.Count; index++)
{
UpstreamPcd[index].LinkPivotAddSeconds(-1);
DownstreamPcd[index].LinkPivotAddSeconds(1);
totalBiasArrivalOnGreen += UpstreamPcd[index].TotalArrivalOnGreen * upstreamBias +
DownstreamPcd[index].TotalArrivalOnGreen * downstreamBias;
totalArrivalOnGreen += UpstreamPcd[index].TotalArrivalOnGreen +
DownstreamPcd[index].TotalArrivalOnGreen;
totalUpstreamAog += UpstreamPcd[index].TotalArrivalOnGreen;
totalDownstreamAog += DownstreamPcd[index].TotalArrivalOnGreen;
}
//Add the total aog to the dictionary
ResultsGraph.Add(i, totalBiasArrivalOnGreen);
UpstreamResultsGraph.Add(i, totalUpstreamAog);
DownstreamResultsGraph.Add(i, totalDownstreamAog);
if (totalBiasArrivalOnGreen > maxBiasArrivalOnGreen)
{
maxBiasArrivalOnGreen = totalBiasArrivalOnGreen;
MaxArrivalOnGreen = totalArrivalOnGreen;
AogUpstreamPredicted = totalUpstreamAog;
AogDownstreamPredicted = totalDownstreamAog;
PaogDownstreamPredicted = Math.Round(totalDownstreamAog / TotalVolumeDownstream, 2) * 100;
PaogUpstreamPredicted = Math.Round(totalUpstreamAog / TotalVolumeUpstream, 2) * 100;
MaxPercentAog =
SecondsAdded = i;
}
}
//Get the link totals
AogTotalPredicted = MaxArrivalOnGreen;
PaogTotalPredicted = Math.Round(AogTotalPredicted / (TotalVolumeUpstream + TotalVolumeDownstream), 2) * 100;
}
private void SetPcds(DateTime endDate, List<DateTime> dates, int cycleTime)
{
foreach (var dt in dates)
{
var tempStartDate = dt;
var tempEndDate = new DateTime(dt.Year, dt.Month, dt.Day, endDate.Hour, endDate.Minute, endDate.Second);
var upstreamPcd = new SignalPhase(tempStartDate, tempEndDate, SignalApproach, false, 15, 13, false, cycleTime);
UpstreamPcd.Add(upstreamPcd);
AogUpstreamBefore += upstreamPcd.TotalArrivalOnGreen;
TotalVolumeUpstream += upstreamPcd.TotalVolume;
var downstreamPcd = new SignalPhase(
tempStartDate, tempEndDate, DownSignalApproach, false, 15, 13, false, cycleTime);
DownstreamPcd.Add(downstreamPcd);
AogDownstreamBefore += downstreamPcd.TotalArrivalOnGreen;
TotalVolumeDownstream += downstreamPcd.TotalVolume;
}
PaogUpstreamBefore = Math.Round(AogUpstreamBefore / TotalVolumeUpstream, 2) * 100;
//AogUpstreamBefore = UpstreamPcd.TotalArrivalOnGreen;
//upstreamBeforePCDPath = CreateChart(upstreamPCD, startDate, endDate, signalLocation,
// "before", chartLocation);
PaogDownstreamBefore = Math.Round(AogDownstreamBefore / TotalVolumeDownstream, 2) * 100;
//aOGDownstreamBefore = downstreamPCD.TotalArrivalOnGreen;
//downstreamBeforePCDPath = CreateChart(downstreamPCD, startDate, endDate, downSignalLocation,
// "before", chartLocation);
}
private void GetNewResultsChart()
{
var chart = new Chart();
//Set the chart properties
ChartFactory.SetImageProperties(chart);
chart.ImageStorageMode = ImageStorageMode.UseImageLocation;
//Set the chart title
var title = new Title();
title.Text = "Max Arrivals On Green By Second";
title.Font = new Font(FontFamily.GenericSansSerif, 20);
chart.Titles.Add(title);
//Create the chart legend
var chartLegend = new Legend();
chartLegend.Name = "MainLegend";
//chartLegend.LegendStyle = LegendStyle.Table;
chartLegend.Docking = Docking.Left;
//chartLegend.CustomItems.Add(Color.Blue, "AoG - Arrival On Green");
//chartLegend.CustomItems.Add(Color.Blue, "GT - Green Time");
//chartLegend.CustomItems.Add(Color.Maroon, "PR - Platoon Ratio");
//LegendCellColumn a = new LegendCellColumn();
//a.ColumnType = LegendCellColumnType.Text;
//a.Text = "test";
//chartLegend.CellColumns.Add(a);
chart.Legends.Add(chartLegend);
//Create the chart area
var chartArea = new ChartArea();
chartArea.Name = "ChartArea1";
chartArea.AxisY.Minimum = 0;
chartArea.AxisY.Title = "Arrivals On Green";
chartArea.AxisY.TitleFont = new Font(FontFamily.GenericSansSerif, 20);
chartArea.AxisY.LabelAutoFitStyle = LabelAutoFitStyles.None;
chartArea.AxisY.LabelStyle.Font = new Font(FontFamily.GenericSansSerif, 20);
chartArea.AxisX.Minimum = 0;
chartArea.AxisX.Title = "Adjustment(seconds)";
chartArea.AxisX.TitleFont = new Font(FontFamily.GenericSansSerif, 20);
chartArea.AxisX.Interval = 10;
chartArea.AxisX.LabelAutoFitStyle = LabelAutoFitStyles.None;
chartArea.AxisX.LabelStyle.Font = new Font(FontFamily.GenericSansSerif, 20);
chart.ChartAreas.Add(chartArea);
//Add the line series
var lineSeries = new Series();
lineSeries.ChartType = SeriesChartType.Line;
lineSeries.Color = Color.Black;
lineSeries.Name = "Total AOG";
lineSeries.XValueType = ChartValueType.Int32;
lineSeries.BorderWidth = 5;
chart.Series.Add(lineSeries);
foreach (var d in ResultsGraph)
chart.Series["Total AOG"].Points.AddXY(
d.Key,
d.Value);
//Add the line series
var downstreamLineSeries = new Series();
downstreamLineSeries.ChartType = SeriesChartType.Line;
downstreamLineSeries.Color = Color.Blue;
downstreamLineSeries.Name = "Downstream AOG";
downstreamLineSeries.XValueType = ChartValueType.Int32;
downstreamLineSeries.BorderWidth = 3;
chart.Series.Add(downstreamLineSeries);
foreach (var d in DownstreamResultsGraph)
chart.Series["Downstream AOG"].Points.AddXY(
d.Key,
d.Value);
//Add the line series
var upstreamLineSeries = new Series();
upstreamLineSeries.ChartType = SeriesChartType.Line;
upstreamLineSeries.Color = Color.Green;
upstreamLineSeries.Name = "Upstream AOG";
upstreamLineSeries.XValueType = ChartValueType.Int32;
upstreamLineSeries.BorderWidth = 3;
chart.Series.Add(upstreamLineSeries);
foreach (var d in UpstreamResultsGraph)
chart.Series["Upstream AOG"].Points.AddXY(
d.Key,
d.Value);
var chartName = "LinkPivot-" + SignalApproach.SignalID + SignalApproach.DirectionType.Abbreviation +
DownSignalApproach.SignalID + DownSignalApproach.DirectionType.Abbreviation +
DateTime.Now.Day +
DateTime.Now.Hour +
DateTime.Now.Minute +
DateTime.Now.Second +
".jpg";
var settingsRepository = MOE.Common.Models.Repositories.ApplicationSettingsRepositoryFactory.Create();
var settings = settingsRepository.GetGeneralSettings();
chart.SaveImage(settings.ImagePath + chartName,
ChartImageFormat.Jpeg);
ResultChartLocation = settings.ImageUrl + chartName;
}
/// <summary>
/// Creates a pcd chart specific to the Link Pivot
/// </summary>
/// <param name="sp"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="location"></param>
/// <param name="chartNameSuffix"></param>
/// <param name="chartLocation"></param>
/// <returns></returns>
private string CreateChart(SignalPhase sp, DateTime startDate, DateTime endDate, string location,
string chartNameSuffix, string chartLocation)
{
var chart = new Chart();
//Display the PDC chart
chart = GetNewChart(startDate, endDate, sp.Approach.SignalID, sp.Approach.ProtectedPhaseNumber,
sp.Approach.DirectionType.Description,
location, sp.Approach.IsProtectedPhaseOverlap, 150, 2000, false, 2);
AddDataToChart(chart, sp, startDate, false, true);
//Create the File Name
var chartName = "LinkPivot-" +
sp.Approach.SignalID +
"-" +
sp.Approach.ProtectedPhaseNumber +
"-" +
startDate.Year +
startDate.ToString("MM") +
startDate.ToString("dd") +
startDate.ToString("HH") +
startDate.ToString("mm") +
"-" +
endDate.Year +
endDate.ToString("MM") +
endDate.ToString("dd") +
endDate.ToString("HH") +
endDate.ToString("mm-") +
chartNameSuffix +
".jpg";
//Save an image of the chart
chart.SaveImage(chartLocation + chartName, ChartImageFormat.Jpeg);
return chartName;
}
/// <summary>
/// Gets a new chart for the pcd Diagram
/// </summary>
/// <param name="graphStartDate"></param>
/// <param name="graphEndDate"></param>
/// <param name="signalId"></param>
/// <param name="phase"></param>
/// <param name="direction"></param>
/// <param name="location"></param>
/// <returns></returns>
private Chart GetNewChart(DateTime graphStartDate, DateTime graphEndDate, string signalId,
int phase, string direction, string location, bool isOverlap, double y1AxisMaximum,
double y2AxisMaximum, bool showVolume, int dotSize)
{
var chart = new Chart();
var extendedDirection = string.Empty;
var movementType = "Phase";
if (isOverlap)
movementType = "Overlap";
//Gets direction for the title
switch (direction)
{
case "SB":
extendedDirection = "Southbound";
break;
case "NB":
extendedDirection = "Northbound";
break;
default:
extendedDirection = direction;
break;
}
//Set the chart properties
ChartFactory.SetImageProperties(chart);
//Set the chart title
var title = new Title();
title.Text = location + "Signal " + signalId + " "
+ movementType + ": " + phase +
" " + extendedDirection + "\n" + graphStartDate.ToString("f") +
" - " + graphEndDate.ToString("f");
title.Font = new Font(FontFamily.GenericSansSerif, 20);
chart.Titles.Add(title);
//Create the chart legend
//Legend chartLegend = new Legend();
//chartLegend.Name = "MainLegend";
////chartLegend.LegendStyle = LegendStyle.Table;
//chartLegend.Docking = Docking.Left;
//chartLegend.CustomItems.Add(Color.Blue, "AoG - Arrival On Green");
//chartLegend.CustomItems.Add(Color.Blue, "GT - Green Time");
//chartLegend.CustomItems.Add(Color.Maroon, "PR - Platoon Ratio");
////LegendCellColumn a = new LegendCellColumn();
////a.ColumnType = LegendCellColumnType.Text;
////a.Text = "test";
////chartLegend.CellColumns.Add(a);
//chart.Legends.Add(chartLegend);
//Create the chart area
var chartArea = new ChartArea();
chartArea.Name = "ChartArea1";
chartArea.AxisY.Maximum = y1AxisMaximum;
chartArea.AxisY.Minimum = 0;
chartArea.AxisY.Title = "Cycle Time (Seconds) ";
chartArea.AxisY.TitleFont = new Font(FontFamily.GenericSansSerif, 20);
chartArea.AxisY.LabelAutoFitStyle = LabelAutoFitStyles.None;
chartArea.AxisY.LabelStyle.Font = new Font(FontFamily.GenericSansSerif, 20);
if (showVolume)
{
chartArea.AxisY2.Enabled = AxisEnabled.True;
chartArea.AxisY2.MajorTickMark.Enabled = true;
chartArea.AxisY2.MajorGrid.Enabled = false;
chartArea.AxisY2.IntervalType = DateTimeIntervalType.Number;
chartArea.AxisY2.Interval = 500;
chartArea.AxisY2.Maximum = y2AxisMaximum;
chartArea.AxisY2.Title = "Volume Per Hour ";
}
chartArea.AxisX.Title = "Time (Hour of Day)";
chartArea.AxisX.TitleFont = new Font(FontFamily.GenericSansSerif, 20);
chartArea.AxisX.Interval = 1;
chartArea.AxisX.IntervalType = DateTimeIntervalType.Hours;
chartArea.AxisX.LabelStyle.Format = "HH";
chartArea.AxisX.LabelAutoFitStyle = LabelAutoFitStyles.None;
chartArea.AxisX.LabelStyle.Font = new Font(FontFamily.GenericSansSerif, 20);
//chartArea.AxisX.Minimum = 0;
chartArea.AxisX2.Enabled = AxisEnabled.True;
chartArea.AxisX2.MajorTickMark.Enabled = true;
chartArea.AxisX2.IntervalType = DateTimeIntervalType.Hours;
chartArea.AxisX2.LabelStyle.Format = "HH";
chartArea.AxisX2.LabelAutoFitStyle = LabelAutoFitStyles.None;
chartArea.AxisX2.Interval = 1;
chartArea.AxisX2.LabelStyle.Font = new Font(FontFamily.GenericSansSerif, 20);
//chartArea.AxisX.Minimum = 0;
chart.ChartAreas.Add(chartArea);
//Add the point series
var pointSeries = new Series();
pointSeries.ChartType = SeriesChartType.Point;
pointSeries.Color = Color.Black;
pointSeries.Name = "Detector Activation";
pointSeries.XValueType = ChartValueType.DateTime;
pointSeries.MarkerSize = dotSize;
chart.Series.Add(pointSeries);
//Add the green series
var greenSeries = new Series();
greenSeries.ChartType = SeriesChartType.Line;
greenSeries.Color = Color.DarkGreen;
greenSeries.Name = "Change to Green";
greenSeries.XValueType = ChartValueType.DateTime;
greenSeries.BorderWidth = 1;
chart.Series.Add(greenSeries);
//Add the yellow series
var yellowSeries = new Series();
yellowSeries.ChartType = SeriesChartType.Line;
yellowSeries.Color = Color.Yellow;
yellowSeries.Name = "Change to Yellow";
yellowSeries.XValueType = ChartValueType.DateTime;
chart.Series.Add(yellowSeries);
//Add the red series
var redSeries = new Series();
redSeries.ChartType = SeriesChartType.Line;
redSeries.Color = Color.Red;
redSeries.Name = "Change to Red";
redSeries.XValueType = ChartValueType.DateTime;
chart.Series.Add(redSeries);
//Add the red series
var volumeSeries = new Series();
volumeSeries.ChartType = SeriesChartType.Line;
volumeSeries.Color = Color.Black;
volumeSeries.Name = "Volume Per Hour";
volumeSeries.XValueType = ChartValueType.DateTime;
volumeSeries.YAxisType = AxisType.Secondary;
chart.Series.Add(volumeSeries);
//Add points at the start and and of the x axis to ensure
//the graph covers the entire period selected by the user
//whether there is data or not
chart.Series["Detector Activation"].Points.AddXY(graphStartDate, 0);
chart.Series["Detector Activation"].Points.AddXY(graphEndDate, 0);
return chart;
}
/// <summary>
/// Adds data points to a graph with the series GreenLine, YellowLine, Redline
/// and Points already added.
/// </summary>
/// <param name="chart"></param>
/// <param name="signalPhase"></param>
/// <param name="startDate"></param>
private void AddDataToChart(Chart chart, SignalPhase signalPhase, DateTime startDate, bool showVolume,
bool showArrivalOnGreen)
{
decimal totalDetectorHits = 0;
decimal totalOnGreenArrivals = 0;
decimal percentArrivalOnGreen = 0;
foreach (var cycle in signalPhase.Cycles)
{
chart.Series["Change to Green"].Points.AddXY(
//pcd.StartTime,
cycle.GreenEvent,
cycle.GreenLineY);
chart.Series["Change to Yellow"].Points.AddXY(
//pcd.StartTime,
cycle.YellowEvent,
cycle.YellowLineY);
chart.Series["Change to Red"].Points.AddXY(
//pcd.StartTime,
cycle.EndTime,
cycle.RedLineY);
totalDetectorHits += cycle.DetectorEvents.Count;
foreach (var detectorPoint in cycle.DetectorEvents)
{
chart.Series["Detector Activation"].Points.AddXY(
//pcd.StartTime,
detectorPoint.TimeStamp,
detectorPoint.YPoint);
if (detectorPoint.YPoint > cycle.GreenLineY && detectorPoint.YPoint < cycle.RedLineY)
totalOnGreenArrivals++;
}
}
if (showVolume)
foreach (var v in signalPhase.Volume.Items)
chart.Series["Volume Per Hour"].Points.AddXY(v.XAxis, v.YAxis);
//if arrivals on green is selected add the data to the chart
if (showArrivalOnGreen)
{
if (totalDetectorHits > 0)
percentArrivalOnGreen = totalOnGreenArrivals / totalDetectorHits * 100;
else
percentArrivalOnGreen = 0;
var title = new Title();
title.Text = Math.Round(percentArrivalOnGreen) + "% AoG";
title.Font = new Font(FontFamily.GenericSansSerif, 20);
chart.Titles.Add(title);
SetPlanStrips(signalPhase.Plans, chart, startDate);
}
}
/// <summary>
/// Adds plan strips to the chart
/// </summary>
/// <param name="planCollection"></param>
/// <param name="chart"></param>
/// <param name="graphStartDate"></param>
protected void SetPlanStrips(List<PlanPcd> planCollection, Chart chart, DateTime graphStartDate)
{
var backGroundColor = 1;
foreach (var plan in planCollection)
{
var stripline = new StripLine();
//Creates alternating backcolor to distinguish the plans
if (backGroundColor % 2 == 0)
stripline.BackColor = Color.FromArgb(120, Color.LightGray);
else
stripline.BackColor = Color.FromArgb(120, Color.LightBlue);
//Set the stripline properties
stripline.IntervalOffset = (plan.StartTime - graphStartDate).TotalHours;
stripline.IntervalOffsetType = DateTimeIntervalType.Hours;
stripline.Interval = 1;
stripline.IntervalType = DateTimeIntervalType.Days;
stripline.StripWidth = (plan.EndTime - plan.StartTime).TotalHours;
stripline.StripWidthType = DateTimeIntervalType.Hours;
chart.ChartAreas["ChartArea1"].AxisX.StripLines.Add(stripline);
//Add a corrisponding custom label for each strip
var Plannumberlabel = new CustomLabel();
Plannumberlabel.FromPosition = plan.StartTime.ToOADate();
Plannumberlabel.ToPosition = plan.EndTime.ToOADate();
switch (plan.PlanNumber)
{
case 254:
Plannumberlabel.Text = "Free";
break;
case 255:
Plannumberlabel.Text = "Flash";
break;
case 0:
Plannumberlabel.Text = "Unknown";
break;
default:
Plannumberlabel.Text = "Plan " + plan.PlanNumber;
break;
}
Plannumberlabel.ForeColor = Color.Black;
Plannumberlabel.RowIndex = 3;
chart.ChartAreas["ChartArea1"].AxisX2.CustomLabels.Add(Plannumberlabel);
var aogLabel = new CustomLabel();
aogLabel.FromPosition = plan.StartTime.ToOADate();
aogLabel.ToPosition = plan.EndTime.ToOADate();
aogLabel.Text = plan.PercentArrivalOnGreen + "% AoG\n" +
plan.PercentGreenTime + "% GT";
aogLabel.LabelMark = LabelMarkStyle.LineSideMark;
aogLabel.ForeColor = Color.Blue;
aogLabel.RowIndex = 2;
chart.ChartAreas["ChartArea1"].AxisX2.CustomLabels.Add(aogLabel);
var statisticlabel = new CustomLabel();
statisticlabel.FromPosition = plan.StartTime.ToOADate();
statisticlabel.ToPosition = plan.EndTime.ToOADate();
statisticlabel.Text =
plan.PlatoonRatio + " PR";
statisticlabel.ForeColor = Color.Maroon;
statisticlabel.RowIndex = 1;
chart.ChartAreas["ChartArea1"].AxisX2.CustomLabels.Add(statisticlabel);
//CustomLabel PlatoonRatiolabel = new CustomLabel();
//PercentGreenlabel.FromPosition = plan.StartTime.ToOADate();
//PercentGreenlabel.ToPosition = plan.EndTime.ToOADate();
//PercentGreenlabel.Text = plan.PlatoonRatio.ToString() + " PR";
//PercentGreenlabel.ForeColor = Color.Black;
//PercentGreenlabel.RowIndex = 1;
//chart.ChartAreas["ChartArea1"].AxisX2.CustomLabels.Add(PercentGreenlabel);
//Change the background color counter for alternating color
backGroundColor++;
}
}
}
} | 48.52071 | 127 | 0.55322 | [
"Apache-2.0"
] | KimleyHorn/ATSPM | MOE.Common/Business/LinkPivotPair.cs | 41,002 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("EngineTests")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EngineTests")]
[assembly: AssemblyCopyright("Copyright © 2019")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("b0f0cde3-90e2-4163-88bc-d10bc832c7f2")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| 37.675676 | 84 | 0.745337 | [
"MIT"
] | StatTag/StatTag | EngineTests/Properties/AssemblyInfo.cs | 1,397 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.ComponentModel;
using System.Windows.Data;
namespace Dependencies
{
public class ModuleSearchResult
{
public string ModuleFilePath { get; set; }
public ModuleSearchStrategy SearchStrategy { get; set; }
}
/// <summary>
/// Interaction logic for ModuleSearchOrder.xaml
/// </summary>
public partial class ModuleSearchOrder : Window
{
public ModuleSearchOrder(ModulesCache LoadedModules)
{
InitializeComponent();
List<ModuleSearchResult> items = new List<ModuleSearchResult>();
foreach (var LoadedModule in LoadedModules.Values)
{
items.Add(new ModuleSearchResult() { ModuleFilePath = LoadedModule.ModuleName, SearchStrategy = LoadedModule.Location });
}
OrderedModules.ItemsSource = items;
CollectionView view = (CollectionView)CollectionViewSource.GetDefaultView(OrderedModules.ItemsSource);
PropertyGroupDescription groupDescription = new PropertyGroupDescription("SearchStrategy");
view.GroupDescriptions.Add(groupDescription);
SortDescription sortDescription = new SortDescription("SearchStrategy", ListSortDirection.Ascending);
view.SortDescriptions.Add(sortDescription);
}
}
}
| 30.191489 | 137 | 0.684989 | [
"MIT"
] | ChristianGutman/Dependencies | DependenciesGui/ModuleSearchOrder.xaml.cs | 1,421 | C# |
// Copyright (c) Stride contributors (https://stride3d.net) and Sean Boettger <[email protected]>
// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
using Stride.Shaders;
namespace Stride.Rendering.Voxels.Debug
{
public partial class VoxelVisualizationRawShaderKeys
{
public static readonly PermutationParameterKey<ShaderSource> Attribute = ParameterKeys.NewPermutation<ShaderSource>();
}
}
| 36.153846 | 126 | 0.774468 | [
"MIT"
] | Aggror/Stride | sources/engine/Stride.Voxels/Voxels/GraphicsCompositor/DebugVisualizations/Shaders/VoxelVisualizationRawShaderKeys.cs | 472 | C# |
/*
* Copyright © 2008, Textfyre, Inc. - All Rights Reserved
* Please read the accompanying COPYRIGHT file for licensing resstrictions.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace FyreVM
{
internal struct HeapEntry
{
public uint Start, Length;
public HeapEntry(uint start, uint length)
{
this.Start = start;
this.Length = length;
}
public override string ToString()
{
return string.Format("Start={0}, Length={1}", Start, Length);
}
}
internal delegate bool MemoryRequester(uint newEndMem);
/// <summary>
/// Manages the heap size and block allocation for the malloc/mfree opcodes.
/// </summary>
/// <remarks>
/// If Inform ever starts using the malloc opcode directly, instead of
/// its own heap allocator, this should be made a little smarter.
/// Currently we make no attempt to avoid heap fragmentation.
/// </remarks>
internal class HeapAllocator
{
private class EntryComparer : IComparer<HeapEntry>
{
public int Compare(HeapEntry x, HeapEntry y)
{
return x.Start.CompareTo(y.Start);
}
}
private static readonly EntryComparer entryComparer = new EntryComparer();
private readonly uint heapAddress;
private readonly MemoryRequester setEndMem;
private readonly List<HeapEntry> blocks; // sorted
private readonly List<HeapEntry> freeList; // sorted
private uint endMem;
private uint heapExtent;
private uint maxHeapExtent;
/// <summary>
/// Initializes a new allocator with an empty heap.
/// </summary>
/// <param name="heapAddress">The address where the heap will start.</param>
/// <param name="requester">A delegate to request more memory.</param>
public HeapAllocator(uint heapAddress, MemoryRequester requester)
{
this.heapAddress = heapAddress;
this.setEndMem = requester;
this.blocks = new List<HeapEntry>();
this.freeList = new List<HeapEntry>();
endMem = heapAddress;
heapExtent = 0;
}
/// <summary>
/// Initializes a new allocator from a previous saved heap state.
/// </summary>
/// <param name="savedHeap">A byte array describing the heap state,
/// as returned by the <see cref="Save"/> method.</param>
/// <param name="requester">A delegate to request more memory.</param>
public HeapAllocator(byte[] savedHeap, MemoryRequester requester)
{
this.heapAddress = BigEndian.ReadInt32(savedHeap, 0);
this.setEndMem = requester;
this.blocks = new List<HeapEntry>();
this.freeList = new List<HeapEntry>();
uint numBlocks = BigEndian.ReadInt32(savedHeap, 4);
blocks.Capacity = (int)numBlocks;
uint nextAddress = heapAddress;
for (uint i = 0; i < numBlocks; i++)
{
uint start = BigEndian.ReadInt32(savedHeap, 8 * i + 8);
uint length = BigEndian.ReadInt32(savedHeap, 8 * i + 12);
blocks.Add(new HeapEntry(start, length));
if (nextAddress < start)
freeList.Add(new HeapEntry(nextAddress, start - nextAddress));
nextAddress = start + length;
}
endMem = nextAddress;
heapExtent = nextAddress - heapAddress;
if (setEndMem(endMem) == false)
throw new ArgumentException("Can't allocate VM memory to fit saved heap");
blocks.Sort(entryComparer);
freeList.Sort(entryComparer);
}
/// <summary>
/// Gets the address where the heap starts.
/// </summary>
public uint Address
{
get { return heapAddress; }
}
/// <summary>
/// Gets the size of the heap, in bytes.
/// </summary>
public uint Size
{
get { return heapExtent; }
}
/// <summary>
/// Gets or sets the maximum allowed size of the heap, in bytes, or 0 to
/// allow an unlimited heap.
/// </summary>
/// <remarks>
/// When a maximum size is set, memory allocations will be refused if they
/// would cause the heap to grow past the maximum size. Setting the maximum
/// size to less than the current <see cref="Size"/> is allowed, but such a
/// value will have no effect until deallocations cause the heap to shrink
/// below the new maximum size.
/// </remarks>
public uint MaxSize
{
get { return maxHeapExtent; }
set { maxHeapExtent = value; }
}
/// <summary>
/// Gets the number of blocks that the allocator is managing.
/// </summary>
public int BlockCount
{
get { return blocks.Count; }
}
/// <summary>
/// Saves the heap state to a byte array.
/// </summary>
/// <returns>A byte array describing the current heap state.</returns>
public byte[] Save()
{
byte[] result = new byte[8 + blocks.Count * 8];
BigEndian.WriteInt32(result, 0, heapAddress);
BigEndian.WriteInt32(result, 4, (uint)blocks.Count);
for (int i = 0; i < blocks.Count; i++)
{
BigEndian.WriteInt32(result, 8 * i + 8, blocks[i].Start);
BigEndian.WriteInt32(result, 8 * i + 12, blocks[i].Length);
}
return result;
}
/// <summary>
/// Allocates a new block on the heap.
/// </summary>
/// <param name="size">The size of the new block, in bytes.</param>
/// <returns>The address of the new block, or 0 if allocation failed.</returns>
public uint Alloc(uint size)
{
HeapEntry result = new HeapEntry(0, size);
// look for a free block
if (freeList != null)
{
for (int i = 0; i < freeList.Count; i++)
{
HeapEntry entry = freeList[i];
if (entry.Length >= size)
{
result.Start = entry.Start;
if (entry.Length > size)
{
// shrink the free block
entry.Start += size;
entry.Length -= size;
freeList[i] = entry;
}
else
freeList.RemoveAt(i);
break;
}
}
}
if (result.Start == 0)
{
// enforce maximum heap size
if (maxHeapExtent != 0 && heapExtent + size > maxHeapExtent)
return 0;
// add a new block at the end
result = new HeapEntry(heapAddress + heapExtent, size);
if (heapAddress + heapExtent + size > endMem)
{
// grow the heap
uint newHeapAllocation = Math.Max(
heapExtent * 5 / 4,
heapExtent + size);
if (maxHeapExtent != 0)
newHeapAllocation = Math.Min(newHeapAllocation, maxHeapExtent);
if (setEndMem(heapAddress + newHeapAllocation))
endMem = heapAddress + newHeapAllocation;
else
return 0;
}
heapExtent += size;
}
// add the new block to the list
int index = ~blocks.BinarySearch(result, entryComparer);
System.Diagnostics.Debug.Assert(index >= 0);
blocks.Insert(index, result);
return result.Start;
}
/// <summary>
/// Deallocates a previously allocated block.
/// </summary>
/// <param name="address">The address of the block to deallocate.</param>
public void Free(uint address)
{
HeapEntry entry = new HeapEntry(address, 0);
int index = blocks.BinarySearch(entry, entryComparer);
if (index >= 0)
{
// delete the block
entry = blocks[index];
blocks.RemoveAt(index);
// adjust the heap extent if necessary
if (entry.Start + entry.Length - heapAddress == heapExtent)
{
if (index == 0)
{
heapExtent = 0;
}
else
{
HeapEntry prev = blocks[index - 1];
heapExtent = prev.Start + prev.Length - heapAddress;
}
}
// add the block to the free list
index = ~freeList.BinarySearch(entry, entryComparer);
System.Diagnostics.Debug.Assert(index >= 0);
freeList.Insert(index, entry);
if (index < freeList.Count - 1)
Coalesce(index, index + 1);
if (index > 0)
Coalesce(index - 1, index);
// shrink the heap if necessary
if (blocks.Count > 0 && heapExtent <= (endMem - heapAddress) / 2)
{
if (setEndMem(heapAddress + heapExtent))
{
endMem = heapAddress + heapExtent;
for (int i = freeList.Count - 1; i >= 0; i--) {
if (freeList[i].Start >= endMem)
freeList.RemoveAt(i);
}
}
}
}
}
private void Coalesce(int index1, int index2)
{
HeapEntry first = freeList[index1];
HeapEntry second = freeList[index2];
if (first.Start + first.Length >= second.Start)
{
first.Length = second.Start + second.Length - first.Start;
freeList[index1] = first;
freeList.RemoveAt(index2);
}
}
}
}
| 34.824841 | 91 | 0.482213 | [
"MIT"
] | ChicagoDave/Zifmia | Textfyre.Zifmia.Service/Textfyre.Zifmia.Service/Textfyre.Zifmia.Service/HeapAllocator.cs | 10,938 | C# |
using System;
using System.Collections.Generic;
namespace NeuralNetworkLibrary
{
public class JordanContextLayer
{
private static Queue<double[]> values;
private static int neurons, layers;
private static double[] current;
public int Neurons => neurons;
public int Layers => layers;
public double[] Current => current;
public JordanContextLayer(int neurons, int layers)
{
JordanContextLayer.neurons = neurons;
JordanContextLayer.layers = layers;
JordanContextLayer.values = new Queue<double[]>(layers);
for (var i = 0; i < layers; i++)
{
JordanContextLayer.values.Enqueue(new double[JordanContextLayer.neurons]);
}
}
private bool Check(double[] values)
{
if (values.Length != JordanContextLayer.neurons)
{
return false;
}
return true;
}
public void Enqueue(double[] values)
{
if (!Check(values))
{
throw new Exception("Number of values passed through is not valid.");
}
JordanContextLayer.values.Enqueue(values);
}
public void Dequeue()
{
JordanContextLayer.current = JordanContextLayer.values.Dequeue();
}
}
} | 25.25 | 90 | 0.549505 | [
"MIT"
] | astrihale/neuralnetwork-maturski | NeuralNetwork/NeuralNetworkLibrary/JordanContextLayer.cs | 1,414 | C# |
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the personalize-2018-05-22.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using System.Text;
using System.IO;
using System.Net;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
namespace Amazon.Personalize.Model
{
/// <summary>
/// Container for the parameters to the DeleteSolution operation.
/// Deletes all versions of a solution and the <code>Solution</code> object itself. Before
/// deleting a solution, you must delete all campaigns based on the solution. To determine
/// what campaigns are using the solution, call <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_ListCampaigns.html">ListCampaigns</a>
/// and supply the Amazon Resource Name (ARN) of the solution. You can't delete a solution
/// if an associated <code>SolutionVersion</code> is in the CREATE PENDING or IN PROGRESS
/// state. For more information on solutions, see <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html">CreateSolution</a>.
/// </summary>
public partial class DeleteSolutionRequest : AmazonPersonalizeRequest
{
private string _solutionArn;
/// <summary>
/// Gets and sets the property SolutionArn.
/// <para>
/// The ARN of the solution to delete.
/// </para>
/// </summary>
[AWSProperty(Required=true, Max=256)]
public string SolutionArn
{
get { return this._solutionArn; }
set { this._solutionArn = value; }
}
// Check to see if SolutionArn property is set
internal bool IsSetSolutionArn()
{
return this._solutionArn != null;
}
}
} | 37.265625 | 157 | 0.683857 | [
"Apache-2.0"
] | Hazy87/aws-sdk-net | sdk/src/Services/Personalize/Generated/Model/DeleteSolutionRequest.cs | 2,385 | C# |
// Copyright 2007 Alp Toker <[email protected]>
// 2011 Bertrand Lorentz <[email protected]>
// This software is made available under the MIT License
// See COPYING for details
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using NUnit.Framework;
using DBus;
using DBus.Protocol;
using org.freedesktop.DBus;
namespace DBus.Tests
{
[TestFixture]
public class ExportInterfaceTest
{
ITestOne test;
Test test_server;
string bus_name = "org.dbussharp.test";
ObjectPath path = new ObjectPath ("/org/dbussharp/test");
int event_a_count = 0;
[TestFixtureSetUp]
public void Setup ()
{
test_server = new Test ();
Bus.Session.Register (path, test_server);
Assert.AreEqual (Bus.Session.RequestName (bus_name), RequestNameReply.PrimaryOwner);
Assert.AreNotEqual (Bus.Session.RequestName (bus_name), RequestNameReply.PrimaryOwner);
test = Bus.Session.GetObject<ITestOne> (bus_name, path);
}
/// <summary>
///
/// </summary>
[Test]
public void VoidMethods ()
{
test.VoidObject (1);
Assert.IsTrue (test_server.void_object_called);
test.VoidEnums (TestEnum.Bar, TestEnum.Foo);
Assert.IsTrue (test_server.void_enums_called);
test.VoidString ("foo");
Assert.IsTrue (test_server.void_enums_called);
}
/// <summary>
///
/// </summary>
[Test]
public void FireEvent ()
{
test.SomeEvent += HandleSomeEventA;
test.FireSomeEvent ();
Assert.AreEqual (1, event_a_count);
test.SomeEvent -= HandleSomeEventA;
test.FireSomeEvent ();
Assert.AreEqual (1, event_a_count);
}
private void HandleSomeEventA (string arg1, object arg2, double arg3, MyTuple mt)
{
event_a_count++;
}
/// <summary>
///
/// </summary>
[Test]
public void GetVariant ()
{
Assert.IsInstanceOfType (typeof (byte []), test.GetSomeVariant());
}
/// <summary>
///
/// </summary>
[Test]
public void WithOutParameters ()
{
uint n;
string istr = "21";
string ostr;
test.WithOutParameters (out n, istr, out ostr);
Assert.AreEqual (UInt32.Parse (istr), n);
Assert.AreEqual ("." + istr + ".", ostr);
uint[] a1, a2, a3;
test.WithOutParameters2 (out a1, out a2, out a3);
Assert.AreEqual (new uint[] { }, a1);
Assert.AreEqual (new uint[] { 21, 23, 16 }, a2);
Assert.AreEqual (new uint[] { 21, 23 }, a3);
}
/// <summary>
///
/// </summary>
[Test]
public void GetPresences ()
{
uint[] @contacts = new uint[] { 2 };
IDictionary<uint,SimplePresence> presences;
test.GetPresences (contacts, out presences);
presences[2] = new SimplePresence { Type = ConnectionPresenceType.Offline, Status = "offline", StatusMessage = "" };
var presence = presences[2];
Assert.AreEqual (ConnectionPresenceType.Offline, presence.Type);
Assert.AreEqual ("offline", presence.Status);
Assert.AreEqual ("", presence.StatusMessage);
}
/// <summary>
///
/// </summary>
[Test]
public void ReturnValues ()
{
string str = "abcd";
Assert.AreEqual (str.Length, test.StringLength (str));
}
/// <summary>
///
/// </summary>
[Test]
public void ComplexAsVariant ()
{
MyTuple2 cpx = new MyTuple2 ();
cpx.A = "a";
cpx.B = "b";
cpx.C = new Dictionary<int,MyTuple> ();
cpx.C[3] = new MyTuple("foo", "bar");
object cpxRet = test.ComplexAsVariant (cpx, 12);
//MyTuple2 mt2ret = (MyTuple2)Convert.ChangeType (cpxRet, typeof (MyTuple2));
var mt2ret = (DBusStruct<string, string, Dictionary<int, DBusStruct<string, string>>>)cpxRet;
Assert.AreEqual (cpx.A, mt2ret.Item1);
Assert.AreEqual (cpx.B, mt2ret.Item2);
Assert.AreEqual (cpx.C[3].A, mt2ret.Item3[3].Item1);
Assert.AreEqual (cpx.C[3].B, mt2ret.Item3[3].Item2);
}
/// <summary>
///
/// </summary>
[Test]
public void Property ()
{
int i = 99;
test.SomeProp = i;
Assert.AreEqual (i, test.SomeProp);
test.SomeProp = i + 1;
Assert.AreEqual (i + 1, test.SomeProp);
}
[Test]
public void AllProperties ()
{
var args = string.Format (
"--dest={0} --type=method_call --print-reply " +
"{1} org.freedesktop.DBus.Properties.GetAll string:{0}",
bus_name,
path
);
Process dbus = new Process {
StartInfo = new ProcessStartInfo {
FileName = "dbus-send",
Arguments = args,
RedirectStandardOutput = true,
UseShellExecute = false
}
};
var iterator = new Thread(() => { do { Bus.Session.Iterate(); } while (true); });
iterator.Start ();
if (dbus.Start ()) {
dbus.WaitForExit ();
string output = dbus.StandardOutput.ReadToEnd ();
Assert.IsNotEmpty (output);
// FIXME: Use a regular expression?
Assert.IsTrue (output.Contains ("SomeProp"));
} else {
Assert.Ignore ("Failed to start test program");
}
iterator.Abort ();
}
/// <summary>
///
/// </summary>
[Test]
public void CatchException ()
{
try {
test.ThrowSomeException ();
Assert.Fail ("An exception should be thrown before getting here");
} catch (Exception ex) {
Assert.IsTrue (ex.Message.Contains ("Some exception"));
}
}
/* Locks up ?
/// <summary>
///
/// </summary>
[Test]
public void ObjectArray ()
{
string str = "The best of times";
ITestOne[] objs = test.GetObjectArray ();
foreach (ITestOne obj in objs) {
Assert.AreEqual (str.Length, obj.StringLength (str));
}
}*/
}
public delegate void SomeEventHandler (string arg1, object arg2, double arg3, MyTuple mt);
[Interface ("org.dbussharp.test")]
public interface ITestOne
{
event SomeEventHandler SomeEvent;
void FireSomeEvent ();
void VoidObject (object obj);
int StringLength (string str);
void VoidEnums (TestEnum a, TestEnum b);
void VoidString (string str);
object GetSomeVariant ();
void ThrowSomeException ();
void WithOutParameters (out uint n, string str, out string ostr);
void WithOutParameters2 (out uint[] a1, out uint[] a2, out uint[] a3);
void GetPresences (uint[] @contacts, out IDictionary<uint,SimplePresence> @presence);
object ComplexAsVariant (object v, int num);
ITestOne[] GetEmptyObjectArray ();
ITestOne[] GetObjectArray ();
int SomeProp { get; set; }
}
public class Test : ITestOne
{
public event SomeEventHandler SomeEvent;
public bool void_enums_called = false;
public bool void_object_called = false;
public bool void_string_called = false;
public void VoidObject (object var)
{
void_object_called = true;
}
public int StringLength (string str)
{
return str.Length;
}
public void VoidEnums (TestEnum a, TestEnum b)
{
void_enums_called = true;
}
public virtual void VoidString (string str)
{
void_string_called = true;
}
/*void IDemoTwo.Say2 (string str)
{
Console.WriteLine ("IDemoTwo.Say2: " + str);
}*/
public void FireSomeEvent ()
{
MyTuple mt;
mt.A = "a";
mt.B = "b";
if (SomeEvent != null) {
SomeEvent ("some string", 21, 19.84, mt);
}
}
public object GetSomeVariant ()
{
return new byte[0];
}
public void ThrowSomeException ()
{
throw new Exception ("Some exception");
}
public void WithOutParameters (out uint n, string str, out string ostr)
{
n = UInt32.Parse (str);
ostr = "." + str + ".";
}
public void WithOutParameters2 (out uint[] a1, out uint[] a2, out uint[] a3)
{
a1 = new uint[] { };
a2 = new uint[] { 21, 23, 16 };
a3 = new uint[] { 21, 23 };
}
public void GetPresences (uint[] @contacts, out IDictionary<uint,SimplePresence> @presence)
{
Dictionary<uint,SimplePresence> presences = new Dictionary<uint,SimplePresence>();
presences[2] = new SimplePresence { Type = ConnectionPresenceType.Offline, Status = "offline", StatusMessage = "" };
presence = presences;
}
public object ComplexAsVariant (object v, int num)
{
return v;
}
public ITestOne[] GetEmptyObjectArray ()
{
return new Test[] {};
}
public ITestOne[] GetObjectArray ()
{
return new ITestOne[] {this};
}
public int SomeProp { get; set; }
}
public enum TestEnum : byte
{
Foo,
Bar,
}
public struct MyTuple
{
public MyTuple (string a, string b)
{
A = a;
B = b;
}
public string A;
public string B;
}
public struct MyTuple2
{
public string A;
public string B;
public IDictionary<int,MyTuple> C;
}
public enum ConnectionPresenceType : uint
{
Unset = 0, Offline = 1, Available = 2, Away = 3, ExtendedAway = 4, Hidden = 5, Busy = 6, Unknown = 7, Error = 8,
}
public struct SimplePresence
{
public ConnectionPresenceType Type;
public string Status;
public string StatusMessage;
}
}
| 22.91601 | 119 | 0.643225 | [
"MIT"
] | AaltoNEPPI/dbus-sharp | tests/ExportInterfaceTest.cs | 8,731 | C# |
using System.Reflection;
[assembly: AssemblyTitle(HSUS.HSUS.Name)]
[assembly: AssemblyDescription("Useful Stuff for Studio and Maker")]
[assembly: AssemblyCompany("https://github.com/IllusionMods/HSPlugins")]
[assembly: AssemblyProduct(HSUS.HSUS.Name)]
[assembly: AssemblyCopyright("Copyright © 2017")]
[assembly: AssemblyVersion(HSUS.HSUS.Version)]
| 39.222222 | 72 | 0.787535 | [
"MIT"
] | IllusionMods/HSPlugins | UsefulStuff.Core/AssemblyInfo.cs | 356 | C# |
using System.Linq;
using System.Threading.Tasks;
using Serilog;
using Witsml;
using Witsml.ServiceReference;
using WitsmlExplorer.Api.Jobs;
using WitsmlExplorer.Api.Models;
using WitsmlExplorer.Api.Query;
using WitsmlExplorer.Api.Services;
namespace WitsmlExplorer.Api.Workers
{
public class DeleteWellWorker : BaseWorker<DeleteWellJob>, IWorker
{
private readonly IWitsmlClient witsmlClient;
public JobType JobType => JobType.DeleteWell;
public DeleteWellWorker(IWitsmlClientProvider witsmlClientProvider)
{
witsmlClient = witsmlClientProvider.GetClient();
}
public override async Task<(WorkerResult, RefreshAction)> Execute(DeleteWellJob job)
{
var wellUid = job.WellReference.WellUid;
var witsmlWell = WellQueries.DeleteWitsmlWell(wellUid);
var result = await witsmlClient.DeleteFromStoreAsync(witsmlWell);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var refreshAction = new RefreshWell(witsmlClient.GetServerHostname(), wellUid, RefreshType.Remove);
var workerResult = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Deleted well with uid ${wellUid}");
return (workerResult, refreshAction);
}
Log.Error("Failed to delete well. WellUid: {WellUid}", wellUid);
witsmlWell = WellQueries.GetWitsmlWellByUid(wellUid);
var queryResult = await witsmlClient.GetFromStoreAsync(witsmlWell, new OptionsIn(ReturnElements.IdOnly));
EntityDescription description = null;
var wellbore = queryResult.Wells.FirstOrDefault();
if (wellbore != null)
{
description = new EntityDescription
{
ObjectName = wellbore.Name
};
}
return (new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to delete well", result.Reason, description), null);
}
}
}
| 36.912281 | 138 | 0.650665 | [
"Apache-2.0"
] | AtleH/witsml-explorer | Src/WitsmlExplorer.Api/Workers/DeleteWellWorker.cs | 2,104 | C# |
/*
* Authentication.cs
*
* Authors:
* Rolf Bjarne Kvinge ([email protected])
*
* Copyright 2009 Novell, Inc. (http://www.novell.com)
*
* See the LICENSE file included with the distribution for details.
*
*/
using System;
using System.Collections.Generic;
using System.Web;
using MonkeyWrench.DataClasses;
using MonkeyWrench.DataClasses.Logic;
using MonkeyWrench.Web.WebServices;
public class Authentication
{
public static void SavePassword (HttpResponse response, LoginResponse ws_response)
{
HttpCookie cookie = new HttpCookie ("cookie", ws_response.Cookie);
cookie.Expires = DateTime.Now.AddDays (1);
response.Cookies.Add (cookie);
HttpCookie person = new HttpCookie ("user", ws_response.User);
person.Expires = DateTime.Now.AddDays (1);
response.Cookies.Add (person);
}
public static bool IsInRole (WebServiceResponse response, string role)
{
if (response.UserRoles == null)
return false;
return Array.IndexOf (response.UserRoles, role) >= 0;
}
} | 25.9 | 84 | 0.710425 | [
"MIT"
] | rolfbjarne/monkeywrench | MonkeyWrench.Web.UI/Code/Authentication.cs | 1,038 | C# |
// -----------------------------------------------------------------------
// <copyright file="EventStream.cs" company="Asynkron AB">
// Copyright (C) 2015-2020 Asynkron AB All rights reserved
// </copyright>
// -----------------------------------------------------------------------
// ReSharper disable once CheckNamespace
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using JetBrains.Annotations;
using Microsoft.Extensions.Logging;
using Proto.Mailbox;
using Proto.Utils;
namespace Proto
{
[PublicAPI]
public class EventStream : EventStream<object>
{
private readonly ILogger _logger = Log.CreateLogger<EventStream>();
internal EventStream() : this(TimeSpan.Zero, 0)
{
}
internal EventStream(TimeSpan throttleInterval, int throttleCount)
{
var shouldThrottle = Throttle.Create(throttleCount, throttleInterval,
droppedLogs => _logger.LogInformation("[DeadLetter] Throttled {LogCount} logs.", droppedLogs)
);
Subscribe<DeadLetterEvent>(
dl =>
{
if (shouldThrottle().IsOpen())
{
_logger.LogInformation(
"[DeadLetter] could not deliver '{MessageType}:{Message}' to '{Target}' from '{Sender}'",
dl.Message.GetType().Name,
dl.Message,
dl.Pid.ToShortString(),
dl.Sender?.ToShortString()
);
}
}
);
}
}
/// <summary>
/// Global event stream of a specific message type
/// </summary>
/// <typeparam name="T">Message type</typeparam>
[PublicAPI]
public class EventStream<T>
{
private readonly ILogger _logger = Log.CreateLogger<EventStream<T>>();
private readonly ConcurrentDictionary<Guid, EventStreamSubscription<T>> _subscriptions = new();
internal EventStream()
{
}
/// <summary>
/// Subscribe to the specified message type
/// </summary>
/// <param name="action">Synchronous message handler</param>
/// <param name="dispatcher">Optional: the dispatcher, will use <see cref="Dispatchers.SynchronousDispatcher" /> by default</param>
/// <returns>A new subscription that can be used to unsubscribe</returns>
public EventStreamSubscription<T> Subscribe(Action<T> action, IDispatcher? dispatcher = null)
{
var sub = new EventStreamSubscription<T>(
this,
dispatcher ?? Dispatchers.SynchronousDispatcher,
x =>
{
action(x);
return Task.CompletedTask;
}
);
_subscriptions.TryAdd(sub.Id, sub);
return sub;
}
/// <summary>
/// Subscribe to the specified message type with an asynchronous handler
/// </summary>
/// <param name="action">Asynchronous message handler</param>
/// <param name="dispatcher">Optional: the dispatcher, will use <see cref="Dispatchers.SynchronousDispatcher" /> by default</param>
/// <returns>A new subscription that can be used to unsubscribe</returns>
public EventStreamSubscription<T> Subscribe(Func<T, Task> action, IDispatcher? dispatcher = null)
{
var sub = new EventStreamSubscription<T>(this, dispatcher ?? Dispatchers.SynchronousDispatcher, action);
_subscriptions.TryAdd(sub.Id, sub);
return sub;
}
/// <summary>
/// Subscribe to the specified message type, which is a derived type from <see cref="T" />
/// </summary>
/// <param name="action">Synchronous message handler</param>
/// <param name="dispatcher">Optional: the dispatcher, will use <see cref="Dispatchers.SynchronousDispatcher" /> by default</param>
/// <returns>A new subscription that can be used to unsubscribe</returns>
public EventStreamSubscription<T> Subscribe<TMsg>(Action<TMsg> action, IDispatcher? dispatcher = null)
where TMsg : T
{
var sub = new EventStreamSubscription<T>(
this,
dispatcher ?? Dispatchers.SynchronousDispatcher,
msg =>
{
if (msg is TMsg typed) action(typed);
return Task.CompletedTask;
}
);
_subscriptions.TryAdd(sub.Id, sub);
return sub;
}
/// <summary>
/// Subscribe to the specified message type, which is a derived type from <see cref="T" />
/// </summary>
/// <param name="predicate">Additional filter upon the typed message</param>
/// <param name="action">Synchronous message handler</param>
/// <param name="dispatcher">Optional: the dispatcher, will use <see cref="Dispatchers.SynchronousDispatcher" /> by default</param>
/// <returns>A new subscription that can be used to unsubscribe</returns>
public EventStreamSubscription<T> Subscribe<TMsg>(Func<TMsg, bool> predicate, Action<TMsg> action,
IDispatcher? dispatcher = null) where TMsg : T
{
var sub = new EventStreamSubscription<T>(
this,
dispatcher ?? Dispatchers.SynchronousDispatcher,
msg =>
{
if (msg is TMsg typed && predicate(typed)) action(typed);
return Task.CompletedTask;
}
);
_subscriptions.TryAdd(sub.Id, sub);
return sub;
}
/// <summary>
/// Subscribe to the specified message type, which is a derived type from <see cref="T" />
/// </summary>
/// <param name="context">The sender context to send from</param>
/// <param name="pids">The target PIDs the message will be sent to</param>
/// <returns>A new subscription that can be used to unsubscribe</returns>
public EventStreamSubscription<T> Subscribe<TMsg>(ISenderContext context, params PID[] pids) where TMsg : T
{
var sub = new EventStreamSubscription<T>(
this,
Dispatchers.SynchronousDispatcher,
msg =>
{
if (msg is TMsg)
{
foreach (var pid in pids)
{
context.Send(pid, msg);
}
}
return Task.CompletedTask;
}
);
_subscriptions.TryAdd(sub.Id, sub);
return sub;
}
/// <summary>
/// Subscribe to the specified message type, which is a derived type from <see cref="T" />
/// </summary>
/// <param name="action">Asynchronous message handler</param>
/// <param name="dispatcher">Optional: the dispatcher, will use <see cref="Dispatchers.SynchronousDispatcher" /> by default</param>
/// <returns>A new subscription that can be used to unsubscribe</returns>
public EventStreamSubscription<T> Subscribe<TMsg>(Func<TMsg, Task> action, IDispatcher? dispatcher = null)
where TMsg : T
{
var sub = new EventStreamSubscription<T>(
this,
dispatcher ?? Dispatchers.SynchronousDispatcher,
msg => msg is TMsg typed ? action(typed) : Task.CompletedTask
);
_subscriptions.TryAdd(sub.Id, sub);
return sub;
}
/// <summary>
/// Publish a message to the event stream
/// </summary>
/// <param name="msg">A message to publish</param>
public void Publish(T msg)
{
foreach (var sub in _subscriptions.Values)
{
sub.Dispatcher.Schedule(
() =>
{
try
{
sub.Action(msg);
}
catch (Exception ex)
{
_logger.LogWarning(0, ex, "Exception has occurred when publishing a message.");
}
return Task.CompletedTask;
}
);
}
}
/// <summary>
/// Remove a subscription by id
/// </summary>
/// <param name="id">Subscription id</param>
public void Unsubscribe(Guid id) => _subscriptions.TryRemove(id, out _);
/// <summary>
/// Remove a subscription
/// </summary>
/// <param name="subscription"> A subscription to remove</param>
public void Unsubscribe(EventStreamSubscription<T>? subscription)
{
if (subscription is not null) Unsubscribe(subscription.Id);
}
}
public class EventStreamSubscription<T>
{
private readonly EventStream<T> _eventStream;
public EventStreamSubscription(EventStream<T> eventStream, IDispatcher dispatcher, Func<T, Task> action)
{
Id = Guid.NewGuid();
_eventStream = eventStream;
Dispatcher = dispatcher;
Action = action;
}
public Guid Id { get; }
public IDispatcher Dispatcher { get; }
public Func<T, Task> Action { get; }
public void Unsubscribe() => _eventStream.Unsubscribe(Id);
}
} | 38.199219 | 139 | 0.531445 | [
"Apache-2.0"
] | dhavalgajera/protoactor-dotnet | src/Proto.Actor/EventStream/EventStream.cs | 9,781 | C# |
using System;
using System.Linq;
using Avalonia.Controls.Primitives;
using Avalonia.Controls.Templates;
using Avalonia.Input;
using Avalonia.Media;
using Xunit;
namespace Avalonia.Controls.UnitTests.Primitives
{
public class ScrollBarTests
{
[Fact]
public void Setting_Value_Should_Update_Track_Value()
{
var target = new ScrollBar
{
Template = new FuncControlTemplate<ScrollBar>(Template),
};
target.ApplyTemplate();
var track = (Track)target.GetTemplateChildren().First(x => x.Name == "track");
target.Value = 50;
Assert.Equal(50, track.Value);
}
[Fact]
public void Setting_Track_Value_Should_Update_Value()
{
var target = new ScrollBar
{
Template = new FuncControlTemplate<ScrollBar>(Template),
};
target.ApplyTemplate();
var track = (Track)target.GetTemplateChildren().First(x => x.Name == "track");
track.Value = 50;
Assert.Equal(50, target.Value);
}
[Fact]
public void Setting_Track_Value_After_Setting_Value_Should_Update_Value()
{
var target = new ScrollBar
{
Template = new FuncControlTemplate<ScrollBar>(Template),
};
target.ApplyTemplate();
var track = (Track)target.GetTemplateChildren().First(x => x.Name == "track");
target.Value = 25;
track.Value = 50;
Assert.Equal(50, target.Value);
}
[Fact]
public void Thumb_DragDelta_Event_Should_Raise_Scroll_Event()
{
var target = new ScrollBar
{
Template = new FuncControlTemplate<ScrollBar>(Template),
};
target.ApplyTemplate();
var track = (Track)target.GetTemplateChildren().First(x => x.Name == "track");
var raisedEvent = Assert.Raises<ScrollEventArgs>(
handler => target.Scroll += handler,
handler => target.Scroll -= handler,
() =>
{
var ev = new VectorEventArgs
{
RoutedEvent = Thumb.DragDeltaEvent,
Vector = new Vector(0, 0)
};
track.Thumb.RaiseEvent(ev);
});
Assert.Equal(ScrollEventType.ThumbTrack, raisedEvent.Arguments.ScrollEventType);
}
[Fact]
public void Thumb_DragComplete_Event_Should_Raise_Scroll_Event()
{
var target = new ScrollBar
{
Template = new FuncControlTemplate<ScrollBar>(Template),
};
target.ApplyTemplate();
var track = (Track)target.GetTemplateChildren().First(x => x.Name == "track");
var raisedEvent = Assert.Raises<ScrollEventArgs>(
handler => target.Scroll += handler,
handler => target.Scroll -= handler,
() =>
{
var ev = new VectorEventArgs
{
RoutedEvent = Thumb.DragCompletedEvent,
Vector = new Vector(0, 0)
};
track.Thumb.RaiseEvent(ev);
});
Assert.Equal(ScrollEventType.EndScroll, raisedEvent.Arguments.ScrollEventType);
}
[Fact]
public void ScrollBar_Can_AutoHide()
{
var target = new ScrollBar();
target.Visibility = ScrollBarVisibility.Auto;
target.ViewportSize = 1;
target.Maximum = 0;
Assert.False(target.IsVisible);
}
[Fact]
public void ScrollBar_Should_Not_AutoHide_When_ViewportSize_Is_NaN()
{
var target = new ScrollBar();
target.Visibility = ScrollBarVisibility.Auto;
target.Minimum = 0;
target.Maximum = 100;
target.ViewportSize = double.NaN;
Assert.True(target.IsVisible);
}
[Fact]
public void ScrollBar_Should_Not_AutoHide_When_Visibility_Set_To_Visible()
{
var target = new ScrollBar();
target.Visibility = ScrollBarVisibility.Visible;
target.Minimum = 0;
target.Maximum = 100;
target.ViewportSize = 100;
Assert.True(target.IsVisible);
}
[Fact]
public void ScrollBar_Should_Hide_When_Visibility_Set_To_Hidden()
{
var target = new ScrollBar();
target.Visibility = ScrollBarVisibility.Hidden;
target.Minimum = 0;
target.Maximum = 100;
target.ViewportSize = 10;
Assert.False(target.IsVisible);
}
private static Control Template(ScrollBar control, INameScope scope)
{
return new Border
{
Child = new Track
{
Name = "track",
[!Track.MinimumProperty] = control[!RangeBase.MinimumProperty],
[!Track.MaximumProperty] = control[!RangeBase.MaximumProperty],
[!!Track.ValueProperty] = control[!!RangeBase.ValueProperty],
[!Track.ViewportSizeProperty] = control[!ScrollBar.ViewportSizeProperty],
[!Track.OrientationProperty] = control[!ScrollBar.OrientationProperty],
Thumb = new Thumb
{
Template = new FuncControlTemplate<Thumb>(ThumbTemplate),
},
}.RegisterInNameScope(scope),
};
}
private static Control ThumbTemplate(Thumb control, INameScope scope)
{
return new Border
{
Background = Brushes.Gray,
};
}
}
}
| 30.5 | 93 | 0.525584 | [
"MIT"
] | 0x0ade/Avalonia | tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs | 6,039 | C# |
using Newtonsoft.Json;
using System;
using System.Globalization;
namespace JGantt.DataModels
{
public class JsonHoliday
{
[JsonProperty("Date")]
public string DateString { get; set; }
[JsonIgnore]
public DateTime Date
{
get
{
return DateTime.ParseExact(this.DateString, "yyyyMMdd", CultureInfo.CurrentCulture);
}
}
public string Colour { get; set; }
}
}
| 21.695652 | 101 | 0.543086 | [
"MIT"
] | SimonPStevens/JGantt | JGantt/DataModels/JsonHoliday.cs | 501 | C# |
using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using CoreAnimation;
using CoreGraphics;
using Foundation;
using UIKit;
using Xunit;
using Xunit.Sdk;
namespace Microsoft.Maui.DeviceTests
{
internal static partial class AssertionExtensions
{
public static string CreateColorAtPointError(this UIImage bitmap, UIColor expectedColor, int x, int y)
{
var data = bitmap.AsPNG();
var imageAsString = data.GetBase64EncodedString(Foundation.NSDataBase64EncodingOptions.None);
return $"Expected {expectedColor} at point {x},{y} in renderered view. This is what it looked like:<img>{imageAsString}</img>";
}
public static string CreateColorError(this UIImage bitmap, string message)
{
var data = bitmap.AsPNG();
var imageAsString = data.GetBase64EncodedString(Foundation.NSDataBase64EncodingOptions.None);
return $"{message}. This is what it looked like:<img>{imageAsString}</img>";
}
// TODO: attach this view to the UI if anything breaks
public static Task AttachAndRun(this UIView view, Action action)
{
action();
return Task.CompletedTask;
}
public static Task<UIImage> ToUIImage(this UIView view)
{
if (view.Superview is WrapperView wrapper)
view = wrapper;
var imageRect = new CGRect(0, 0, view.Frame.Width, view.Frame.Height);
UIGraphics.BeginImageContext(imageRect.Size);
var context = UIGraphics.GetCurrentContext();
view.Layer.RenderInContext(context);
var image = UIGraphics.GetImageFromCurrentImageContext();
UIGraphics.EndImageContext();
return Task.FromResult(image);
}
public static UIColor ColorAtPoint(this UIImage bitmap, int x, int y)
{
var pixel = bitmap.GetPixel(x, y);
var color = new UIColor(
pixel[0] / 255.0f,
pixel[1] / 255.0f,
pixel[2] / 255.0f,
pixel[3] / 255.0f);
return color;
}
public static byte[] GetPixel(this UIImage bitmap, int x, int y)
{
var cgImage = bitmap.CGImage;
var width = cgImage.Width;
var height = cgImage.Height;
var colorSpace = CGColorSpace.CreateDeviceRGB();
var bitsPerComponent = 8;
var bytesPerRow = 4 * width;
var componentCount = 4;
var dataBytes = new byte[width * height * componentCount];
using var context = new CGBitmapContext(
dataBytes,
width, height,
bitsPerComponent, bytesPerRow,
colorSpace,
CGBitmapFlags.ByteOrder32Big | CGBitmapFlags.PremultipliedLast);
context.DrawImage(new CGRect(0, 0, width, height), cgImage);
var pixelLocation = (bytesPerRow * y) + componentCount * x;
var pixel = new byte[]
{
dataBytes[pixelLocation],
dataBytes[pixelLocation + 1],
dataBytes[pixelLocation + 2],
dataBytes[pixelLocation + 3],
};
return pixel;
}
public static UIImage AssertColorAtPoint(this UIImage bitmap, UIColor expectedColor, int x, int y)
{
var cap = bitmap.ColorAtPoint(x, y);
if (!ColorComparison.ARGBEquivalent(cap, expectedColor))
Assert.Equal(cap, expectedColor, new ColorComparison());
return bitmap;
}
public static UIImage AssertColorAtCenter(this UIImage bitmap, UIColor expectedColor)
{
AssertColorAtPoint(bitmap, expectedColor, (int)bitmap.Size.Width / 2, (int)bitmap.Size.Height / 2);
return bitmap;
}
public static UIImage AssertColorAtBottomLeft(this UIImage bitmap, UIColor expectedColor)
{
return bitmap.AssertColorAtPoint(expectedColor, 0, 0);
}
public static UIImage AssertColorAtBottomRight(this UIImage bitmap, UIColor expectedColor)
{
return bitmap.AssertColorAtPoint(expectedColor, (int)bitmap.Size.Width - 1, 0);
}
public static UIImage AssertColorAtTopLeft(this UIImage bitmap, UIColor expectedColor)
{
return bitmap.AssertColorAtPoint(expectedColor, 0, (int)bitmap.Size.Height - 1);
}
public static UIImage AssertColorAtTopRight(this UIImage bitmap, UIColor expectedColor)
{
return bitmap.AssertColorAtPoint(expectedColor, (int)bitmap.Size.Width - 1, (int)bitmap.Size.Height - 1);
}
public static async Task<UIImage> AssertColorAtPoint(this UIView view, UIColor expectedColor, int x, int y)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertColorAtPoint(expectedColor, x, y);
}
public static async Task<UIImage> AssertColorAtCenter(this UIView view, UIColor expectedColor)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertColorAtCenter(expectedColor);
}
public static async Task<UIImage> AssertColorAtBottomLeft(this UIView view, UIColor expectedColor)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertColorAtBottomLeft(expectedColor);
}
public static async Task<UIImage> AssertColorAtBottomRight(this UIView view, UIColor expectedColor)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertColorAtBottomRight(expectedColor);
}
public static async Task<UIImage> AssertColorAtTopLeft(this UIView view, UIColor expectedColor)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertColorAtTopLeft(expectedColor);
}
public static async Task<UIImage> AssertColorAtTopRight(this UIView view, UIColor expectedColor)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertColorAtTopRight(expectedColor);
}
public static async Task<UIImage> AssertContainsColor(this UIView view, UIColor expectedColor)
{
var bitmap = await view.ToUIImage();
return bitmap.AssertContainsColor(expectedColor);
}
public static Task<UIImage> AssertContainsColor(this UIView view, Microsoft.Maui.Graphics.Color expectedColor) =>
AssertContainsColor(view, expectedColor.ToNative());
public static UIImage AssertContainsColor(this UIImage bitmap, UIColor expectedColor)
{
for (int x = 0; x < bitmap.Size.Width; x++)
{
for (int y = 0; y < bitmap.Size.Height; y++)
{
if (ColorComparison.ARGBEquivalent(bitmap.ColorAtPoint(x, y), expectedColor))
{
return bitmap;
}
}
}
Assert.True(false, CreateColorError(bitmap, $"Color {expectedColor} not found."));
return bitmap;
}
public static UILineBreakMode ToNative(this LineBreakMode mode) =>
mode switch
{
LineBreakMode.NoWrap => UILineBreakMode.Clip,
LineBreakMode.WordWrap => UILineBreakMode.WordWrap,
LineBreakMode.CharacterWrap => UILineBreakMode.CharacterWrap,
LineBreakMode.HeadTruncation => UILineBreakMode.HeadTruncation,
LineBreakMode.TailTruncation => UILineBreakMode.TailTruncation,
LineBreakMode.MiddleTruncation => UILineBreakMode.MiddleTruncation,
_ => throw new ArgumentOutOfRangeException(nameof(mode))
};
public static double GetCharacterSpacing(this NSAttributedString text)
{
if (text == null)
return 0;
var value = text.GetAttribute(UIStringAttributeKey.KerningAdjustment, 0, out var range);
if (value == null)
return 0;
Assert.Equal(0, range.Location);
Assert.Equal(text.Length, range.Length);
var kerning = Assert.IsType<NSNumber>(value);
return kerning.DoubleValue;
}
public static void AssertHasUnderline(this NSAttributedString attributedString)
{
var value = attributedString.GetAttribute(UIStringAttributeKey.UnderlineStyle, 0, out var range);
if (value == null)
{
throw new XunitException("Label does not have the UnderlineStyle attribute");
}
}
public static UIColor GetForegroundColor(this NSAttributedString text)
{
if (text == null)
return UIColor.Clear;
var value = text.GetAttribute(UIStringAttributeKey.ForegroundColor, 0, out var range);
if (value == null)
return UIColor.Clear;
Assert.Equal(0, range.Location);
Assert.Equal(text.Length, range.Length);
var kerning = Assert.IsType<UIColor>(value);
return kerning;
}
public static void AssertEqual(this CATransform3D expected, CATransform3D actual, int precision = 4)
{
Assert.Equal((double)expected.m11, (double)actual.m11, precision);
Assert.Equal((double)expected.m12, (double)actual.m12, precision);
Assert.Equal((double)expected.m13, (double)actual.m13, precision);
Assert.Equal((double)expected.m14, (double)actual.m14, precision);
Assert.Equal((double)expected.m21, (double)actual.m21, precision);
Assert.Equal((double)expected.m22, (double)actual.m22, precision);
Assert.Equal((double)expected.m23, (double)actual.m23, precision);
Assert.Equal((double)expected.m24, (double)actual.m24, precision);
Assert.Equal((double)expected.m31, (double)actual.m31, precision);
Assert.Equal((double)expected.m32, (double)actual.m32, precision);
Assert.Equal((double)expected.m33, (double)actual.m33, precision);
Assert.Equal((double)expected.m34, (double)actual.m34, precision);
Assert.Equal((double)expected.m41, (double)actual.m41, precision);
Assert.Equal((double)expected.m42, (double)actual.m42, precision);
Assert.Equal((double)expected.m43, (double)actual.m43, precision);
Assert.Equal((double)expected.m44, (double)actual.m44, precision);
}
}
} | 32.402174 | 130 | 0.734094 | [
"MIT"
] | 3DSX/maui | src/Core/tests/DeviceTests/AssertionExtensions.iOS.cs | 8,945 | C# |
using System.Reflection;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ConsoleWebServer.Application")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ConsoleWebServer.Application")]
[assembly: AssemblyCopyright("Telerik Academy © 2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("40ba6b5a-7fa7-41d1-aaf6-5cf676b46b79")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")] | 39.685714 | 84 | 0.75018 | [
"MIT"
] | dushka-dragoeva/TelerikSeson2016 | Exam Preparations/HQC -Part 2/ConsoleWebServer/ConsoleWebServer/ConsoleWebServer.Application/Properties/AssemblyInfo.cs | 1,392 | C# |
using System;
using DotNetCore.CAP.Models;
namespace DotNetCore.CAP.Processor.States
{
public class FailedState : IState
{
public const string StateName = "Failed";
public TimeSpan? ExpiresAfter => TimeSpan.FromDays(15);
public string Name => StateName;
public void Apply(CapPublishedMessage message, IStorageTransaction transaction)
{
}
public void Apply(CapReceivedMessage message, IStorageTransaction transaction)
{
}
}
} | 23.363636 | 87 | 0.66537 | [
"MIT"
] | hybirdtheory/CAP | src/DotNetCore.CAP/Processor/States/IState.Failed.cs | 516 | C# |
namespace VstsPipelineSync
{
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using DevOpsLib;
using Microsoft.Azure.Services.AppAuthentication;
using Microsoft.Azure.KeyVault;
class Program
{
static async Task Main(string[] args)
{
(HashSet<string> branches, TimeSpan waitPeriodBeforeNextUpdate, string pat, string dbConnectionString) = GetInputsFromArgs(args);
Console.WriteLine($"Wait period before next update=[{waitPeriodBeforeNextUpdate}]");
await new VstsBuildBatchUpdate(new DevOpsAccessSetting(pat), dbConnectionString, branches).RunAsync(waitPeriodBeforeNextUpdate, CancellationToken.None);
}
private static (HashSet<string> branches, TimeSpan waitPeriodBeforeNextUpdate, string pat, string dbConnectionString) GetInputsFromArgs(string[] args)
{
if (args.Length != 2 && args.Length != 4)
{
Console.WriteLine("*** This program will ingest vsts data and upload to the database used by the iotedge test dashboard.");
Console.WriteLine("By default, it will authenticate with the database and vsts using secrets from keyvault. You can also handle the auth yourself using command line args.");
Console.WriteLine("VstsBuildBatchUpdate.exe <branches> <wait-period> [<vsts-pat> <db-connection-string>] ");
Console.WriteLine("Usage:");
Console.WriteLine(" branches: comma deliminated name of branches");
Console.WriteLine(" wait-period: time between db updates (e.g. 00:01:00)");
Console.WriteLine(" vsts-pat: personal access token to vsts");
Console.WriteLine(" db-connection-string: sql server connection string found in the azure portal");
Environment.Exit(1);
}
HashSet<string> branches = new HashSet<string>(args[0].Split(","));
TimeSpan waitPeriodBeforeNextUpdate = TimeSpan.Parse(args[1]);
string pat;
string dbConnectionString;
if (args.Length == 4)
{
pat = args[2];
dbConnectionString = args[3];
}
else
{
pat = GetSecretFromKeyVault_ManagedIdentity_TokenProvider("TestDashboardVstsPat");
dbConnectionString = GetSecretFromKeyVault_ManagedIdentity_TokenProvider("TestDashboardDbConnectionString");
}
return (branches, waitPeriodBeforeNextUpdate, pat, dbConnectionString);
}
// Reference from https://zimmergren.net/azure-container-instances-managed-identity-key-vault-dotnet-core/
private static string GetSecretFromKeyVault_ManagedIdentity_TokenProvider(string secretName)
{
Console.WriteLine($"Getting secret from keyvault: {secretName}");
AzureServiceTokenProvider tokenProvider = new AzureServiceTokenProvider();
var keyVault = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(tokenProvider.KeyVaultTokenCallback));
var secretResult = keyVault.GetSecretAsync("https://edgebuildkv.vault.azure.net/", secretName).Result;
return secretResult.Value;
}
}
}
| 49.656716 | 189 | 0.661557 | [
"MIT"
] | kajakIYD/iotedge | tools/IoTEdgeDevOps/VstsPipelineSync/Program.cs | 3,327 | C# |
using System;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Xml.Schema;
using System.Xml.Serialization;
namespace Workday.Admissions
{
[GeneratedCode("System.Xml", "4.6.1590.0"), DesignerCategory("code"), DebuggerStepThrough, XmlType(Namespace = "urn:com.workday/bsvc")]
[Serializable]
public class Engagement_Action_Item_AssignableObjectIDType : INotifyPropertyChanged
{
private string typeField;
private string valueField;
[method: CompilerGenerated]
[CompilerGenerated]
public event PropertyChangedEventHandler PropertyChanged;
[XmlAttribute(Form = XmlSchemaForm.Qualified)]
public string type
{
get
{
return this.typeField;
}
set
{
this.typeField = value;
this.RaisePropertyChanged("type");
}
}
[XmlText]
public string Value
{
get
{
return this.valueField;
}
set
{
this.valueField = value;
this.RaisePropertyChanged("Value");
}
}
protected void RaisePropertyChanged(string propertyName)
{
PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
if (propertyChanged != null)
{
propertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
}
}
| 20.95082 | 136 | 0.730829 | [
"MIT"
] | matteofabbri/Workday.WebServices | Workday.AdmissionsService/Engagement_Action_Item_AssignableObjectIDType.cs | 1,278 | C# |
namespace Microsoft.Azure.PowerShell.Cmdlets.Functions.Models.Api20190801
{
using static Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Extensions;
/// <summary>Database connection string information.</summary>
public partial class ConnStringInfo
{
/// <summary>
/// <c>AfterFromJson</c> will be called after the json deserialization has finished, allowing customization of the object
/// before it is returned. Implement this method in a partial class to enable this behavior
/// </summary>
/// <param name="json">The JsonNode that should be deserialized into this object.</param>
partial void AfterFromJson(Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject json);
/// <summary>
/// <c>AfterToJson</c> will be called after the json erialization has finished, allowing customization of the <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject"
/// /> before it is returned. Implement this method in a partial class to enable this behavior
/// </summary>
/// <param name="container">The JSON container that the serialization result will be placed in.</param>
partial void AfterToJson(ref Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject container);
/// <summary>
/// <c>BeforeFromJson</c> will be called before the json deserialization has commenced, allowing complete customization of
/// the object before it is deserialized.
/// If you wish to disable the default deserialization entirely, return <c>true</c> in the <see "returnNow" /> output parameter.
/// Implement this method in a partial class to enable this behavior.
/// </summary>
/// <param name="json">The JsonNode that should be deserialized into this object.</param>
/// <param name="returnNow">Determines if the rest of the deserialization should be processed, or if the method should return
/// instantly.</param>
partial void BeforeFromJson(Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject json, ref bool returnNow);
/// <summary>
/// <c>BeforeToJson</c> will be called before the json serialization has commenced, allowing complete customization of the
/// object before it is serialized.
/// If you wish to disable the default serialization entirely, return <c>true</c> in the <see "returnNow" /> output parameter.
/// Implement this method in a partial class to enable this behavior.
/// </summary>
/// <param name="container">The JSON container that the serialization result will be placed in.</param>
/// <param name="returnNow">Determines if the rest of the serialization should be processed, or if the method should return
/// instantly.</param>
partial void BeforeToJson(ref Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject container, ref bool returnNow);
/// <summary>
/// Deserializes a Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject into a new instance of <see cref="ConnStringInfo" />.
/// </summary>
/// <param name="json">A Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject instance to deserialize from.</param>
internal ConnStringInfo(Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject json)
{
bool returnNow = false;
BeforeFromJson(json, ref returnNow);
if (returnNow)
{
return;
}
{_name = If( json?.PropertyT<Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonString>("name"), out var __jsonName) ? (string)__jsonName : (string)Name;}
{_type = If( json?.PropertyT<Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonString>("type"), out var __jsonType) ? (string)__jsonType : (string)Type;}
{_connectionString = If( json?.PropertyT<Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonString>("connectionString"), out var __jsonConnectionString) ? (string)__jsonConnectionString : (string)ConnectionString;}
AfterFromJson(json);
}
/// <summary>
/// Deserializes a <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode"/> into an instance of Microsoft.Azure.PowerShell.Cmdlets.Functions.Models.Api20190801.IConnStringInfo.
/// </summary>
/// <param name="node">a <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode" /> to deserialize from.</param>
/// <returns>
/// an instance of Microsoft.Azure.PowerShell.Cmdlets.Functions.Models.Api20190801.IConnStringInfo.
/// </returns>
public static Microsoft.Azure.PowerShell.Cmdlets.Functions.Models.Api20190801.IConnStringInfo FromJson(Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode node)
{
return node is Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject json ? new ConnStringInfo(json) : null;
}
/// <summary>
/// Serializes this instance of <see cref="ConnStringInfo" /> into a <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode" />.
/// </summary>
/// <param name="container">The <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject"/> container to serialize this object into. If the caller
/// passes in <c>null</c>, a new instance will be created and returned to the caller.</param>
/// <param name="serializationMode">Allows the caller to choose the depth of the serialization. See <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.SerializationMode"/>.</param>
/// <returns>
/// a serialized instance of <see cref="ConnStringInfo" /> as a <see cref="Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode" />.
/// </returns>
public Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode ToJson(Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject container, Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.SerializationMode serializationMode)
{
container = container ?? new Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonObject();
bool returnNow = false;
BeforeToJson(ref container, ref returnNow);
if (returnNow)
{
return container;
}
AddIf( null != (((object)this._name)?.ToString()) ? (Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode) new Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonString(this._name.ToString()) : null, "name" ,container.Add );
AddIf( null != (((object)this._type)?.ToString()) ? (Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode) new Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonString(this._type.ToString()) : null, "type" ,container.Add );
AddIf( null != (((object)this._connectionString)?.ToString()) ? (Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonNode) new Microsoft.Azure.PowerShell.Cmdlets.Functions.Runtime.Json.JsonString(this._connectionString.ToString()) : null, "connectionString" ,container.Add );
AfterToJson(ref container);
return container;
}
}
} | 72.714286 | 298 | 0.68854 | [
"MIT"
] | Arsasana/azure-powershell | src/Functions/generated/api/Models/Api20190801/ConnStringInfo.json.cs | 7,531 | C# |
//------------------------------------------------------------------------------
// Copyright (c) 2014-2016 the original author or authors. All Rights Reserved.
//
// NOTICE: You are permitted to use, modify, and distribute this file
// in accordance with the terms of the license agreement accompanying it.
//------------------------------------------------------------------------------
using Robotlegs.Bender.Extensions.EventManagement.API;
using Robotlegs.Bender.Extensions.Mediation.API;
namespace Robotlegs.Bender.Extensions.Mediation.API
{
public interface IEventView : IView
{
IEventDispatcher dispatcher{ get; set;}
}
}
| 33.894737 | 81 | 0.576087 | [
"MIT"
] | KieranBond/robotlegs-sharp-framework | src/Robotlegs/Bender/Extensions/Mediation/API/IEventView.cs | 644 | C# |
// See LICENSE file in the root directory
//
using System;
using UnityEditor;
namespace LGK.Inspector.StandardDrawer
{
public class BoolTypeDrawer : ITypeDrawer
{
public Type TargetType
{
get { return typeof(bool); }
}
public object Draw(IMemberInfo memberInfo, object memberValue, string label)
{
var value = (bool)memberValue;
if (memberInfo.IsReadOnly)
{
EditorGUILayout.LabelField(label, value.ToString());
}
else
{
return EditorGUILayout.Toggle(label, value);
}
return memberValue;
}
}
} | 21.78125 | 84 | 0.545194 | [
"MIT"
] | NED-Studio/LGK.Inspector | LGK.Inspector/Editor/StandardDrawer/BoolTypeDrawer.cs | 697 | C# |
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
namespace System.Web.Mvc.Test
{
public class SelectListTest
{
[Fact]
public void Constructor1SetsProperties()
{
// Arrange
IEnumerable items = new object[0];
// Act
SelectList selectList = new SelectList(items);
// Assert
Assert.Same(items, selectList.Items);
Assert.Null(selectList.DataValueField);
Assert.Null(selectList.DataTextField);
Assert.Null(selectList.SelectedValues);
Assert.Null(selectList.SelectedValue);
}
[Fact]
public void Constructor2SetsProperties_Items_SelectedValue()
{
// Arrange
IEnumerable items = new object[0];
object selectedValue = new object();
// Act
SelectList selectList = new SelectList(items, selectedValue);
List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();
// Assert
Assert.Same(items, selectList.Items);
Assert.Null(selectList.DataValueField);
Assert.Null(selectList.DataTextField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues);
Assert.Same(selectedValue, selectedValues[0]);
}
[Fact]
public void Constructor3SetsProperties_SelectedValue_DisabledValues()
{
// Arrange
IEnumerable items = new[] { "A", "B", "C" };
IEnumerable selectedValues = "A";
IEnumerable disabledValues = new[] { "B", "C" };
// Act
SelectList multiSelect = new SelectList(items, selectedValues, disabledValues);
// Assert
Assert.Same(items, multiSelect.Items);
Assert.Equal(new object[] { selectedValues }, multiSelect.SelectedValues);
Assert.Equal(disabledValues, multiSelect.DisabledValues);
Assert.Null(multiSelect.DataTextField);
Assert.Null(multiSelect.DataValueField);
}
[Fact]
public void Constructor3SetsProperties_Value_Text()
{
// Arrange
IEnumerable items = new object[0];
// Act
SelectList selectList = new SelectList(items, "SomeValueField", "SomeTextField");
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("SomeValueField", selectList.DataValueField);
Assert.Equal("SomeTextField", selectList.DataTextField);
Assert.Null(selectList.SelectedValues);
Assert.Null(selectList.SelectedValue);
}
[Fact]
public void Constructor4SetsProperties()
{
// Arrange
IEnumerable items = new object[0];
object selectedValue = new object();
// Act
SelectList selectList = new SelectList(items, "SomeValueField", "SomeTextField", selectedValue);
List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("SomeValueField", selectList.DataValueField);
Assert.Equal("SomeTextField", selectList.DataTextField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues);
Assert.Same(selectedValue, selectedValues[0]);
}
[Fact]
public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_DisabledValues()
{
// Arrange
IEnumerable items = new[]
{
new { Value = "A", Text = "Alice" },
new { Value = "B", Text = "Bravo" },
new { Value = "C", Text = "Charlie" },
};
object selectedValue = "A";
IEnumerable disabledValues = new[] { "B", "C" };
// Act
SelectList selectList = new SelectList(items,
"Value",
"Text",
selectedValue,
disabledValues);
List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("Value", selectList.DataValueField);
Assert.Equal("Text", selectList.DataTextField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues);
Assert.Same(selectedValue, selectedValues[0]);
Assert.Same(disabledValues, selectList.DisabledValues);
Assert.Equal(disabledValues, selectList.DisabledValues);
Assert.Null(selectList.DataGroupField);
Assert.Null(selectList.DisabledGroups);
}
[Fact]
public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_Group()
{
// Arrange
IEnumerable items = new[]
{
new { Value = "A", Text = "Alice", Group = "AB" },
new { Value = "B", Text = "Bravo", Group = "AB" },
new { Value = "C", Text = "Charlie", Group = "C" },
};
object selectedValue = "A";
// Act
SelectList selectList = new SelectList(items,
"Value",
"Text",
"Group",
selectedValue);
List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("Value", selectList.DataValueField);
Assert.Equal("Text", selectList.DataTextField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues);
Assert.Same(selectedValue, selectedValues[0]);
Assert.Equal("Group", selectList.DataGroupField);
}
[Fact]
public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_Group_DisabledGroups()
{
// Arrange
IEnumerable items = new[]
{
new { Value = "A", Text = "Alice", Group = "AB" },
new { Value = "B", Text = "Bravo", Group = "AB" },
new { Value = "C", Text = "Charlie", Group = "C" },
};
object selectedValue = "A";
IEnumerable disabledGroups = new[] { "AB" };
// Act
SelectList selectList = new SelectList(items,
"Value",
"Text",
"Group",
selectedValue,
null,
disabledGroups);
List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("Value", selectList.DataValueField);
Assert.Equal("Text", selectList.DataTextField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues);
Assert.Same(selectedValue, selectedValues[0]);
Assert.Equal("Group", selectList.DataGroupField);
Assert.Equal(disabledGroups, selectList.DisabledGroups);
}
[Fact]
public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_DisabledValues_Group()
{
// Arrange
IEnumerable items = new[]
{
new { Value = "A", Text = "Alice", Group = "AB" },
new { Value = "B", Text = "Bravo", Group = "AB" },
new { Value = "C", Text = "Charlie", Group = "C" },
};
object selectedValue = "A";
IEnumerable disabledValues = new[] { "A", "C" };
// Act
SelectList selectList = new SelectList(items,
"Value",
"Text",
"Group",
selectedValue,
disabledValues);
List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("Value", selectList.DataValueField);
Assert.Equal("Text", selectList.DataTextField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues);
Assert.Same(selectedValue, selectedValues[0]);
Assert.Equal("Group", selectList.DataGroupField);
Assert.Same(disabledValues, selectList.DisabledValues);
}
[Fact]
public void DataGroupFieldSetByCtor()
{
// Arrange
IEnumerable items = new object[0];
object selectedValue = new object();
// Act
SelectList selectList = new SelectList(items, "SomeValueField", "SomeTextField", "SomeGroupField",
selectedValue);
IEnumerable selectedValues = selectList.SelectedValues;
// Assert
Assert.Same(items, selectList.Items);
Assert.Equal("SomeValueField", selectList.DataValueField);
Assert.Equal("SomeTextField", selectList.DataTextField);
Assert.Equal("SomeGroupField", selectList.DataGroupField);
Assert.Same(selectedValue, selectList.SelectedValue);
Assert.Single(selectedValues, selectedValue);
Assert.Null(selectList.DisabledValues);
Assert.Null(selectList.DisabledGroups);
}
}
}
| 38.053846 | 133 | 0.564686 | [
"Apache-2.0"
] | Darth-Fx/AspNetMvcStack | test/System.Web.Mvc.Test/Test/SelectListTest.cs | 9,896 | C# |
using System.Linq.Expressions;
namespace Apaf.NFSdb.Core.Queries.Queryable.Expressions
{
public class ComparisonExpression: QlExpression
{
public ComparisonExpression(Expression left, ExpressionType operation, Expression right, QlToken token)
: base(token)
{
Left = left;
Operation = operation;
Right = right;
}
public ExpressionType Operation { get; private set; }
public Expression Right { get; private set; }
public Expression Left { get; private set; }
public override ExpressionType NodeType
{
get { return Operation; }
}
public override string ToString()
{
return string.Format("({0} {1} {2})", Left, Operation, Right);
}
}
} | 28.137931 | 111 | 0.591912 | [
"Apache-2.0"
] | NFSdb/nfsdb-csharp | Apaf.NFSdb.Core/Queries/Queryable/Expressions/ComparisonExpression.cs | 818 | C# |
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows;
// Управление общими сведениями о сборке осуществляется с помощью
// набора атрибутов. Измените значения этих атрибутов, чтобы изменить сведения,
// связанные со сборкой.
[assembly: AssemblyTitle("OsEngine")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Sib Algo")]
[assembly: AssemblyProduct("OsEngine")]
[assembly: AssemblyCopyright("Sib Algo")]
[assembly: AssemblyTrademark("Os.Engine")]
[assembly: AssemblyCulture("")]
// Параметр ComVisible со значением FALSE делает типы в сборке невидимыми
// для COM-компонентов. Если требуется обратиться к типу в этой сборке через
// COM, задайте атрибуту ComVisible значение TRUE для этого типа.
[assembly: ComVisible(false)]
//Чтобы начать сборку локализованных приложений, задайте
//<UICulture>CultureYouAreCodingWith</UICulture> в файле .csproj
//внутри <PropertyGroup>. Например, если используется английский США
//в своих исходных файлах установите <UICulture> в en-US. Затем отмените преобразование в комментарий
//атрибута NeutralResourceLanguage ниже. Обновите "en-US" в
//строка внизу для обеспечения соответствия настройки UICulture в файле проекта.
//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
[assembly: ThemeInfo(
ResourceDictionaryLocation.None, //где расположены словари ресурсов по конкретным тематикам
//(используется, если ресурс не найден на странице
// или в словарях ресурсов приложения)
ResourceDictionaryLocation.SourceAssembly //где расположен словарь универсальных ресурсов
//(используется, если ресурс не найден на странице,
// в приложении или в каких-либо словарях ресурсов для конкретной темы)
)]
// Сведения о версии сборки состоят из следующих четырех значений:
//
// Основной номер версии
// Дополнительный номер версии
// Номер сборки
// Редакция
//
// Можно задать все значения или принять номера сборки и редакции по умолчанию
// используя "*", как показано ниже:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.2")]
[assembly: AssemblyFileVersion("1.0.0.2")]
| 41.092593 | 102 | 0.769265 | [
"Apache-2.0"
] | gridgentoo/OsEngine.ADO.NET | project/OsEngine/Properties/AssemblyInfo.cs | 3,208 | C# |
// Copyright (c) Josef Pihrt. All rights reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Text.RegularExpressions;
namespace Roslynator.CSharp.Refactorings.Tests
{
internal class SplitSwitchLabelsRefactoring
{
public static void Foo(RegexOptions options)
{
switch (options)
{
case RegexOptions.CultureInvariant:
case RegexOptions.ECMAScript:
break;
case RegexOptions.ExplicitCapture:
case RegexOptions.IgnoreCase:
case RegexOptions.IgnorePatternWhitespace:
break;
case RegexOptions.Multiline:
case RegexOptions.None:
case RegexOptions.RightToLeft:
case RegexOptions.Singleline:
break;
}
}
}
}
| 32.931034 | 160 | 0.58534 | [
"Apache-2.0"
] | ADIX7/Roslynator | src/Tests/Refactorings.Tests.Old/SplitSwitchLabelsRefactoring.cs | 957 | C# |
// Part of FreeLibSet.
// See copyright notices in "license" file in the FreeLibSet root directory.
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Data;
using System.ComponentModel;
using FreeLibSet.IO;
using FreeLibSet.Formatting;
using System.Diagnostics;
using FreeLibSet.DependedValues;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using FreeLibSet.Core;
using FreeLibSet.Data;
using FreeLibSet.Shell;
using FreeLibSet.Logging;
namespace FreeLibSet.Forms
{
#region Перечисления
/// <summary>
/// Значения свойства EFPDataGridView.State
/// </summary>
public enum EFPDataGridViewState
{
/// <summary>
/// Режим просмотра.
/// В этом режиме табличный просмотр находится постоянно, пока не выбрана одна из команд редактирования.
/// Также используется, если выбрана команда "Просмотреть запись".
/// </summary>
View,
/// <summary>
/// Выбрана команда "Редактировать запись".
/// </summary>
Edit,
/// <summary>
/// Выбрана команда "Новая запись"
/// </summary>
Insert,
/// <summary>
/// Выбранная команда "Копия записи"
/// </summary>
InsertCopy,
/// <summary>
/// Выбрана команда "Удалить запись"
/// </summary>
Delete,
};
/// <summary>
/// Сколько строк сейчас выбрано в просмотре: Одна, ни одной или несколько
/// (свойство EFPDataGridView.SelectedRowState)
/// </summary>
public enum EFPDataGridViewSelectedRowsState
{
/// <summary>
/// Выбрана одна ячейка или одна строка целиком или несколько ячеек в одной строке
/// </summary>
SingleRow,
/// <summary>
/// Выбрано несколько строк или ячейки, расположенные на разных строках
/// </summary>
MultiRows,
/// <summary>
/// Нет ни одной выбранной ячейки (просмотр пуст)
/// </summary>
NoSelection
}
#endregion
#region Цветовые атрибуты ячейки
#region Перечисления
#region EFPDataGridViewColorType
/// <summary>
/// Аргумент для метода SetCellAttr()
/// </summary>
public enum EFPDataGridViewColorType
{
/// <summary>
/// Обычная ячейка
/// </summary>
Normal,
/// <summary>
/// Альтернативный цвет для создания "полосатых" просмотров, когда строки
/// (обычно, через одну) имеют немного отличающийся цвет
/// </summary>
Alter,
/// <summary>
/// Выделение серым цветом
/// </summary>
Special,
/// <summary>
/// Итог 1 (зеленые строки)
/// </summary>
Total1,
/// <summary>
/// Подытог 2 (сиреневые строки)
/// </summary>
Total2,
/// <summary>
/// Итоговая строка по всей таблице
/// </summary>
TotalRow,
/// <summary>
/// Заголовок
/// </summary>
Header,
/// <summary>
/// Ячейка с ошибкой (красный фон).
/// </summary>
Error,
/// <summary>
/// Ячейка с предупреждением (ярко-желтый фон, красные буквы)
/// </summary>
Warning,
}
#endregion
#region EFPDataGridViewBorderStyle
/// <summary>
/// Типы границы ячейки
/// </summary>
public enum EFPDataGridViewBorderStyle
{
/// <summary>
/// Граница по умолчанию (в зависимости от оформления границ таблицы)
/// </summary>
Default,
/// <summary>
/// Отключить границу
/// (требуется, чтобы граница была отключена и у соседней ячейки)
/// </summary>
None,
/// <summary>
/// Тонкая линия
/// </summary>
Thin,
/// <summary>
/// Толстая линия
/// </summary>
Thick
}
#endregion
#region EFPDataGridViewAttributesReason
/// <summary>
/// Для чего вызывается событие EFPDataGridView.GetRowAttributes или GetCellAttributes
/// </summary>
public enum EFPDataGridViewAttributesReason
{
/// <summary>
/// Для вывода на экран
/// </summary>
View,
/// <summary>
/// Для вывода на печать или для предварительного просмотра
/// </summary>
Print,
/// <summary>
/// Обрабатывается сообщение CellToolTipNeeded для заголовка строки
/// </summary>
ToolTip,
/// <summary>
/// Определяется возможность редактирования ячейки. Обработчик события
/// CellBeginEdit или вызван метод GetCellReadOnly
/// </summary>
ReadOnly,
}
#endregion
#region EFPDataGridViewImageKind
/// <summary>
/// Изображения, которые можно выводить в заголовке строк
/// С помощью свойства UserImage можно задавать произвольные изображения
/// </summary>
public enum EFPDataGridViewImageKind
{
/// <summary>
/// Нет изображения
/// </summary>
None,
/// <summary>
/// Значок "i"
/// </summary>
Information,
/// <summary>
/// Восклицательный знак
/// </summary>
Warning,
/// <summary>
/// Ошибка (красный крест)
/// </summary>
Error,
}
#endregion
#endregion
/// <summary>
/// Базовый класс для EFPDataGridViewRowAttributesEventArgs и
/// EFPDataGridViewCellAttributesEventArgs
/// </summary>
public class EFPDataGridViewCellAttributesEventArgsBase : EventArgs
{
#region Конструктор
internal EFPDataGridViewCellAttributesEventArgsBase(EFPDataGridView controlProvider, bool isCellAttributes)
{
_ControlProvider = controlProvider;
_IsCellAttributes = isCellAttributes;
}
#endregion
#region Свойства - исходные данные
/// <summary>
/// Обработчик табличного просмотра
/// </summary>
public EFPDataGridView ControlProvider { get { return _ControlProvider; } }
private EFPDataGridView _ControlProvider;
/// <summary>
/// Табличный просмотр
/// </summary>
public DataGridView Control { get { return ControlProvider.Control; } }
/// <summary>
/// Зачем было вызвано событие: для вывода на экран или для печати
/// </summary>
public EFPDataGridViewAttributesReason Reason { get { return _Reason; } }
private EFPDataGridViewAttributesReason _Reason;
/// <summary>
/// Номер строки, для которой требуются атрибуты, в табличном просмотре
/// </summary>
public int RowIndex { get { return _RowIndex; } }
private int _RowIndex;
/// <summary>
/// Доступ к строке таблицы данных, если источником данных для табличного
/// просмотра является DataView. Иначе - null
/// </summary>
public DataRowView RowView
{
get
{
DataView dv = ControlProvider.SourceAsDataView;
if (dv == null)
return null;
else
return dv[RowIndex];
}
}
/// <summary>
/// Доступ к строке таблицы данных, если источником данных для табличного
/// просмотра является DataView. Иначе - null
/// </summary>
public DataRow DataRow
{
get
{
return ControlProvider.GetDataRow(RowIndex);
}
}
/// <summary>
/// Доступ к строке табличного просмотра.
/// Вызов метода делает строку Unshared
/// </summary>
/// <returns></returns>
public DataGridViewRow GetGridRow()
{
if (RowIndex < 0)
return null;
return Control.Rows[RowIndex];
}
private bool _IsCellAttributes;
#endregion
#region Устанавливаемые свойства
/// <summary>
/// Цветовое оформление строки или ячейки.
/// Установка значения в EFPDataGridViewColorType.TotalRow для объекта EFPDataGridViewRowAttributesEventArgs приводит дополнительно
/// к установке свойств TopBorder и BottomBorder в значение Thick, что удобно для оформления таблиц отчетов.
/// Чтобы посторониие свойства не устанавливались, используйте метод SetColorTypeOnly()
/// </summary>
public EFPDataGridViewColorType ColorType
{
get { return _ColorType; }
set
{
_ColorType = value;
if (value == EFPDataGridViewColorType.TotalRow)
{
if (!_IsCellAttributes) // 17.07.2019
{
//LeftBorder = EFPDataGridViewBorderStyle.Thick;
TopBorder = EFPDataGridViewBorderStyle.Thick;
//RightBorder = EFPDataGridViewBorderStyle.Thick;
BottomBorder = EFPDataGridViewBorderStyle.Thick;
}
}
}
}
private EFPDataGridViewColorType _ColorType;
/// <summary>
/// Установка свойства ColorType без неявной установки других свойств
/// </summary>
/// <param name="value">Значение свойства</param>
public void SetColorTypeOnly(EFPDataGridViewColorType value)
{
_ColorType = value;
}
/// <summary>
/// Если установить в true, то текст ячейки будет рисоваться серым шрифтом
/// По умолчанию - false
/// </summary>
public bool Grayed
{
get
{
if (_Grayed.HasValue)
return _Grayed.Value;
else
return false;
}
set
{
_Grayed = value;
}
}
internal bool? _Grayed;
/// <summary>
/// Левая граница ячейки, используемая при печати
/// </summary>
public EFPDataGridViewBorderStyle LeftBorder { get { return _LeftBorder; } set { _LeftBorder = value; } }
private EFPDataGridViewBorderStyle _LeftBorder;
/// <summary>
/// Верняя граница ячейки, используемая при печати
/// </summary>
public EFPDataGridViewBorderStyle TopBorder { get { return _TopBorder; } set { _TopBorder = value; } }
private EFPDataGridViewBorderStyle _TopBorder;
/// <summary>
/// Правая граница ячейки, используемая при печати
/// </summary>
public EFPDataGridViewBorderStyle RightBorder { get { return _RightBorder; } set { _RightBorder = value; } }
private EFPDataGridViewBorderStyle _RightBorder;
/// <summary>
/// Нижняя граница ячейки, используемая при печати
/// </summary>
public EFPDataGridViewBorderStyle BottomBorder { get { return _BottomBorder; } set { _BottomBorder = value; } }
private EFPDataGridViewBorderStyle _BottomBorder;
/// <summary>
/// Перечеркивание ячейки от левого нижнего угла к правому верхнему.
/// В отличие от других границ, работает в режиме просмотра.
/// Значение Default идентично None.
/// </summary>
public EFPDataGridViewBorderStyle DiagonalUpBorder { get { return _DiagonalUpBorder; } set { _DiagonalUpBorder = value; } }
private EFPDataGridViewBorderStyle _DiagonalUpBorder;
/// <summary>
/// Перечеркивание ячейки от левого верхнего угла к правому нижнему.
/// В отличие от других границ, работает в режиме просмотра.
/// Значение Default идентично None.
/// </summary>
public EFPDataGridViewBorderStyle DiagonalDownBorder { get { return _DiagonalDownBorder; } set { _DiagonalDownBorder = value; } }
private EFPDataGridViewBorderStyle _DiagonalDownBorder;
/// <summary>
/// Используется в режиме Reason=ReadOnly
/// </summary>
public bool ReadOnly { get { return _ReadOnly; } set { _ReadOnly = value; } }
private bool _ReadOnly;
/// <summary>
/// Используется в режиме Reason=ReadOnly
/// Текст сообщения, почему нельзя редактировать строку / ячейку
/// </summary>
public string ReadOnlyMessage { get { return _ReadOnlyMessage; } set { _ReadOnlyMessage = value; } }
private string _ReadOnlyMessage;
#endregion
#region Методы
/// <summary>
/// Устанавливает четыре границы (свойства LeftBorder, TopBorder, RightBorder, BottomBorder), используемые для печати.
/// Свойства DiagonalUpBorder и DiagonalDownBorder не меняются
/// </summary>
/// <param name="style">Вид границы</param>
public void SetAllBorders(EFPDataGridViewBorderStyle style)
{
SetAllBorders(style, false);
}
/// <summary>
/// Устанавливает границы (свойства LeftBorder, TopBorder, RightBorder, BottomBorder), используемые для печати.
/// Также может устанавливать свойства DiagonalUpBorder и DiagonalDownBorder.
/// </summary>
/// <param name="style">Вид границы</param>
/// <param name="diagonals">Если true, то дополнительно будет установлены свойства DiagonalUpBorder и DiagonalDownBorder</param>
public void SetAllBorders(EFPDataGridViewBorderStyle style, bool diagonals)
{
LeftBorder = style;
TopBorder = style;
RightBorder = style;
BottomBorder = style;
if (diagonals)
{
DiagonalUpBorder = style;
DiagonalDownBorder = style;
}
}
#endregion
#region Защищенные методы
/// <summary>
/// Инициализация аргументов
/// </summary>
/// <param name="rowIndex">Индекс строки табличного просмотра</param>
/// <param name="reason">Свойство Reason</param>
protected void InitRow(int rowIndex, EFPDataGridViewAttributesReason reason)
{
_RowIndex = rowIndex;
_Reason = reason;
ColorType = EFPDataGridViewColorType.Normal;
_Grayed = null;
LeftBorder = EFPDataGridViewBorderStyle.Default;
TopBorder = EFPDataGridViewBorderStyle.Default;
RightBorder = EFPDataGridViewBorderStyle.Default;
BottomBorder = EFPDataGridViewBorderStyle.Default;
DiagonalUpBorder = EFPDataGridViewBorderStyle.Default;
DiagonalDownBorder = EFPDataGridViewBorderStyle.Default;
}
#endregion
}
/// <summary>
/// Аргументы события EFPDataGridView.GetRowAttributes
/// </summary>
public class EFPDataGridViewRowAttributesEventArgs : EFPDataGridViewCellAttributesEventArgsBase
{
#region Конструктор
/// <summary>
/// Создает аргументы события
/// </summary>
/// <param name="controlProvider">Провайдер табличного просмотра</param>
public EFPDataGridViewRowAttributesEventArgs(EFPDataGridView controlProvider)
: base(controlProvider, false)
{
CellErrorMessages = new Dictionary<int, ErrorMessageList>();
}
#endregion
#region Устанавливаемые свойства
/// <summary>
/// При печати запретить отрывать текущую строку от предыдущей
/// </summary>
public bool PrintWithPrevious { get { return _PrintWithPrevious; } set { _PrintWithPrevious = value; } }
private bool _PrintWithPrevious;
/// <summary>
/// При печати запретить отрывать текущую строку от следующей
/// </summary>
public bool PrintWithNext { get { return _PrintWithNext; } set { _PrintWithNext = value; } }
private bool _PrintWithNext;
/// <summary>
/// Изображение, которое будет выведено в заголовке строки (в серой ячейке)
/// Должно быть установлено свойство EFPDataGridView.UseRowImages
/// Это свойство также используется при навигации по Ctrl-[, Ctrl-]
/// Стандартный значок может быть переопределен установкой свойства UserImage
/// </summary>
public EFPDataGridViewImageKind ImageKind { get { return _ImageKind; } set { _ImageKind = value; } }
private EFPDataGridViewImageKind _ImageKind;
/// <summary>
/// Переопределение изображения, которое будет выведено в заголовке строки
/// (в серой ячейке)
/// Если свойство не установлено (по умолчанию), то используются стандартные
/// значки для ImageKind=Information,Warning и Error, или пустое изображение
/// при ImageKind=None.
/// Свойство не влияет на навигацию по строкам по Ctrl-[, Ctrl-]
/// Должно быть установлено свойство EFPDataGridView.UseRowImages
/// </summary>
public Image UserImage { get { return _UserImage; } set { _UserImage = value; } }
private Image _UserImage;
/// <summary>
/// Всплывающая подсказка, которая будет выведена при наведении курсора на
/// ячейку заголовка строки. Поле должно заполняться только при Reason=ToolTip.
/// В других режимах значение игнорируется
/// </summary>
public string ToolTipText { get { return _ToolTipText; } set { _ToolTipText = value; } }
private string _ToolTipText;
/// <summary>
/// Используется методом EFPDataGridView.GetRowErrorMessages
/// </summary>
internal ErrorMessageList RowErrorMessages;
/// <summary>
/// Словарь для сообщений об ошибках в ячейках
/// Ключом является индекс столбца ColumnIndex
/// </summary>
internal Dictionary<int, ErrorMessageList> CellErrorMessages;
/// <summary>
/// Идентификатор строки, используемый при построении списка сообщений об ошибках.
/// Если свойство явно не устанавливается в обработчике GetRowAttributes, оно принимает значение по умолчанию
/// </summary>
public string RowIdText
{
get
{
if (String.IsNullOrEmpty(_RowIdText))
return DefaultRowIdText;
else
return _RowIdText;
}
set
{
_RowIdText = value;
}
}
private string _RowIdText;
/// <summary>
/// Идентификатор строки по умолчанию.
/// Если установлено свойство EFPDataGridView.RowIdTextDataColumnName
/// </summary>
public string DefaultRowIdText
{
get
{
if (!String.IsNullOrEmpty(ControlProvider.RowIdTextDataColumnName))
{
if (DataRow == null)
return "Нет строки";
return DataTools.GetString(DataRow, ControlProvider.RowIdTextDataColumnName);
}
// Значение по умолчанию
return "Строка " + (RowIndex + 1).ToString();
}
}
/// <summary>
/// Используется вместо штучной установки свойства ContentVisible в обработчике
/// GetCellAttributes. По умолчанию - true. Если свойство сбросить в false,
/// то для всех ячеек типа DataGridViewCheckBoxCell, DataGridViewButtonCell и
/// DataGridViewComboBoxCell будет устанавливаться свойство ContentVisible=false
/// </summary>
public bool ControlContentVisible { get { return _ControlContentVisible; } set { _ControlContentVisible = value; } }
private bool _ControlContentVisible;
#endregion
#region Сообщения об ошибках и подсказки
#region Основные методы
/// <summary>
/// Устанавливает для строки подходящее изображение и добавляет сообщения
/// к свойству ToolTipText из списка ошибок
/// Эквивалентно вызову метода AddRowErrorMessage() для каждого сообщения в списке
/// </summary>
/// <param name="errors">Список ошибок</param>
public void AddRowErrorMessages(ErrorMessageList errors)
{
if (errors == null)
return;
for (int i = 0; i < errors.Count; i++)
AddRowErrorMessage(errors[i]);
}
/// <summary>
/// Устанавливает для строки подходящее изображение и добавляет сообщение
/// к свойству ToolTipText.
/// Эквивалентно одному из вызовов: AddRowError(), AddRowWarning() или
/// AddRowInformation()
/// </summary>
/// <param name="kind">Важность: Ошибка, предупреждение или сообщение</param>
/// <param name="message">Текст сообщения</param>
public void AddRowErrorMessage(ErrorMessageKind kind, string message)
{
AddRowErrorMessage(new ErrorMessageItem(kind, message));
}
/// <summary>
/// Устанавливает для строки подходящее изображение и добавляет сообщение
/// к свойству ToolTipText.
/// Эквивалентно одному из вызовов: AddRowError(), AddRowWarning() или
/// AddRowInformation()
/// </summary>
/// <param name="error">Объект ошибки ErrorMessageItem</param>
public void AddRowErrorMessage(ErrorMessageItem error)
{
AddRowErrorMessage(error, String.Empty);
}
/// <summary>
/// Устанавливает для строки подходящее изображение и добавляет сообщение
/// к свойству ToolTipText.
/// Позволяет привязать сообщение об ошибке и задать подсветку для выбранных ячеек строки.
/// Эквивалентно одному из вызовов: AddRowError(), AddRowWarning() или
/// AddRowInformation()
/// </summary>
/// <param name="error">Объект ошибки ErrorMessageItem</param>
/// <param name="columnNames">Список имен столбцов (через запятую), для которых задается подсветка ошибки</param>
public void AddRowErrorMessage(ErrorMessageItem error, string columnNames)
{
EFPDataGridViewImageKind NewImageKind;
switch (error.Kind)
{
case ErrorMessageKind.Error: NewImageKind = EFPDataGridViewImageKind.Error; break;
case ErrorMessageKind.Warning: NewImageKind = EFPDataGridViewImageKind.Warning; break;
case ErrorMessageKind.Info: NewImageKind = EFPDataGridViewImageKind.Information; break;
default:
throw new ArgumentException("Неправильное значение Error.Kind=" + error.Kind.ToString());
}
if ((int)NewImageKind > (int)ImageKind)
ImageKind = NewImageKind;
AddToolTipText(error.Text);
if (RowErrorMessages != null)
RowErrorMessages.Add(new ErrorMessageItem(error.Kind, error.Text, error.Code, RowIndex)); // исправлено 09.11.2014
if (!String.IsNullOrEmpty(columnNames))
{
if (columnNames.IndexOf(',') >= 0)
{
string[] a = columnNames.Split(',');
for (int i = 0; i < a.Length; i++)
AddOneCellErrorMessage(error, a[i]);
}
else
AddOneCellErrorMessage(error, columnNames);
}
}
private void AddOneCellErrorMessage(ErrorMessageItem error, string columnName)
{
int ColumnIndex = ControlProvider.Columns.IndexOf(columnName);
if (ColumnIndex < 0)
return; // имя несуществующего столбца
ErrorMessageList Errors;
if (!CellErrorMessages.TryGetValue(ColumnIndex, out Errors))
{
Errors = new ErrorMessageList();
CellErrorMessages.Add(ColumnIndex, Errors);
}
Errors.Add(error);
}
private void AddToolTipText(string message)
{
if (Reason != EFPDataGridViewAttributesReason.ToolTip &&
Reason != EFPDataGridViewAttributesReason.View) // 15.09.2015 Сообщения для невиртуального просмотра
return;
#if DEBUG
if (String.IsNullOrEmpty(message))
throw new ArgumentNullException("message");
#endif
if (String.IsNullOrEmpty(ToolTipText))
ToolTipText = message;
else
ToolTipText += Environment.NewLine + message;
}
#endregion
#region Дополнительные методы
/// <summary>
/// Устанавливает для строки изображение ошибки и добавляет сообщение к свойству
/// ToolTipText
/// </summary>
/// <param name="message">Сообщение</param>
public void AddRowError(string message)
{
AddRowErrorMessage(new ErrorMessageItem(ErrorMessageKind.Error, message), String.Empty);
}
/// <summary>
/// Устанавливает для строки изображение ошибки и добавляет сообщение к свойству
/// ToolTipText
/// Позволяет привязать сообщение об ошибке и задать подсветку для выбранных ячеек строки.
/// </summary>
/// <param name="message">Сообщение</param>
/// <param name="columnNames">Список имен столбцов (через запятую), для которых задается подсветка ошибки</param>
public void AddRowError(string message, string columnNames)
{
AddRowErrorMessage(new ErrorMessageItem(ErrorMessageKind.Error, message), columnNames);
}
/// <summary>
/// Устанавливает для строки изображение предупреждения (если оно не установлено уже в ошибку)
/// и добавляет сообщение к свойству ToolTipText
/// </summary>
/// <param name="message">Сообщение</param>
public void AddRowWarning(string message)
{
AddRowErrorMessage(new ErrorMessageItem(ErrorMessageKind.Warning, message), String.Empty);
}
/// <summary>
/// Устанавливает для строки изображение предупреждения (если оно не установлено уже в ошибку)
/// и добавляет сообщение к свойству ToolTipText
/// Позволяет привязать предупреждение и задать подсветку для выбранных ячеек строки.
/// </summary>
/// <param name="message">Сообщение</param>
/// <param name="columnNames">Список имен столбцов (через запятую), для которых задается подсветка предупреждения</param>
public void AddRowWarning(string message, string columnNames)
{
AddRowErrorMessage(new ErrorMessageItem(ErrorMessageKind.Warning, message), columnNames);
}
/// <summary>
/// Устанавливает для строки изображение сообщения и добавляет сообщение к свойству
/// ToolTipText
/// </summary>
/// <param name="message">Сообщение</param>
public void AddRowInformation(string message)
{
AddRowErrorMessage(new ErrorMessageItem(ErrorMessageKind.Info, message), String.Empty);
}
/// <summary>
/// Устанавливает для строки изображение сообщения и добавляет сообщение к свойству
/// ToolTipText.
/// Позволяет привязать сообщение для выбранных ячеек строки.
/// </summary>
/// <param name="message">Сообщение</param>
/// <param name="columnNames">Список имен столбцов (через запятую), для которых задается всплывающая подсказка</param>
public void AddRowInformation(string message, string columnNames)
{
AddRowErrorMessage(new ErrorMessageItem(ErrorMessageKind.Info, message), columnNames);
}
#endregion
#endregion
#region Защишенные методы
/// <summary>
/// Инициализация аргументов
/// </summary>
/// <param name="rowIndex">Индекс строки табличного просмотра</param>
/// <param name="reason">Свойство Reason</param>
public new void InitRow(int rowIndex, EFPDataGridViewAttributesReason reason)
{
base.InitRow(rowIndex, reason);
PrintWithPrevious = false;
PrintWithNext = false;
ImageKind = EFPDataGridViewImageKind.None;
UserImage = null;
ToolTipText = String.Empty;
// Эмуляция стандартного поведения DataGridView по обработке DataRow.RowError
if (ControlProvider.UseRowImagesDataError)
{
DataRow Row = this.DataRow;
if (Row != null)
{
ToolTipText = Row.RowError;
if (!String.IsNullOrEmpty(ToolTipText))
ImageKind = EFPDataGridViewImageKind.Error;
}
}
ReadOnly = false;
ReadOnlyMessage = "Строка предназначена только для просмотра";
if (reason == EFPDataGridViewAttributesReason.ReadOnly)
{
DataGridViewRow GridRow = ControlProvider.Control.Rows.SharedRow(rowIndex);
ReadOnly = (GridRow.GetState(rowIndex) & DataGridViewElementStates.ReadOnly) == DataGridViewElementStates.ReadOnly;
}
ControlContentVisible = true;
CellErrorMessages.Clear();
RowIdText = null;
}
#endregion
}
/// <summary>
/// Аргументы события EFPDataGridView.GetCellAttributes
/// </summary>
public class EFPDataGridViewCellAttributesEventArgs : EFPDataGridViewCellAttributesEventArgsBase
{
#region Конструктор
/// <summary>
/// Создает аргуметы события
/// </summary>
/// <param name="controlProvider">Провайдер табличного просмотра</param>
public EFPDataGridViewCellAttributesEventArgs(EFPDataGridView controlProvider)
: base(controlProvider, true)
{
}
#endregion
#region Свойства - исходные данные
/// <summary>
/// Индекс столбца в табличном просмотре (независимо от текущего порядка столбцов).
/// Совпадает с DataGridViewColumn.Index
/// </summary>
public int ColumnIndex { get { return _ColumnIndex; } }
private int _ColumnIndex;
/// <summary>
/// Объект столбца в EFPDataGridView
/// </summary>
public EFPDataGridViewColumn Column { get { return _Column; } }
private EFPDataGridViewColumn _Column;
/// <summary>
/// Объект столбца в DataGridView
/// </summary>
public DataGridViewColumn GridColumn { get { return Column.GridColumn; } }
/// <summary>
/// Имя столбца DataGridViewColumn.Name
/// </summary>
public string ColumnName { get { return Column.Name; } }
/// <summary>
/// Настройки вида ячейки для выравнивания и др. атрибутов
/// </summary>
public DataGridViewCellStyle CellStyle
{
get
{
if (_CellStyle == null)
_CellStyle = new DataGridViewCellStyle(_TemplateCellStyle);
return _CellStyle;
}
}
private DataGridViewCellStyle _CellStyle;
/// <summary>
/// Вместо реального стиля, который можно непосредственно менять, может быть
/// использован шаблон стиля. В этом случае будет сгенерирован новый объект
/// при любом обращении к CellStyle
/// </summary>
private DataGridViewCellStyle _TemplateCellStyle;
/// <summary>
/// Используется в DoGetCellAttributes() после вызова обработчика, чтобы вызвавший
/// модуль мог работать с CellStyle не задумываясь о лишнем копировании
/// </summary>
internal void MoveTemplateToStyle()
{
if (_CellStyle == null)
_CellStyle = _TemplateCellStyle;
}
/// <summary>
/// Доступ к ячейке табличного просмотра.
/// Вызов метода делает строку Unshared
/// </summary>
/// <returns>Объект ячейки</returns>
public DataGridViewCell GetGridCell()
{
if (ColumnIndex < 0)
return null;
else
{
DataGridViewRow r = GetGridRow();
if (r == null)
return null;
else
return r.Cells[ColumnIndex];
}
}
/// <summary>
/// Исходное (неотформатированное) значение
/// </summary>
public object OriginalValue { get { return _OriginalValue; } }
private object _OriginalValue;
#endregion
#region Устанавливаемые свойства
/// <summary>
/// Форматируемое значение
/// </summary>
public object Value { get { return _Value; } set { _Value = value; } }
private object _Value;
/// <summary>
/// Свойство должно быть установлено в true, если было применено форматирование
/// значения
/// </summary>
public bool FormattingApplied { get { return _FormattingApplied; } set { _FormattingApplied = value; } }
private bool _FormattingApplied;
/// <summary>
/// Отступ от левого или от правого края (в зависимости от горизонтального
/// выравнивания) значения ячейки
/// </summary>
public int IndentLevel { get { return _IndentLevel; } set { _IndentLevel = value; } }
private int _IndentLevel;
/// <summary>
/// Возвращает значение Value или OriginalValue, в зависимости от наличия значений
/// и свойства FormattingApplied
/// Это значение должно использоваться для вывода
/// </summary>
public object FormattedValue
{
get
{
if (FormattingApplied)
return Value;
else
{
if (OriginalValue == null || OriginalValue is DBNull)
return Value;
else
return OriginalValue;
}
}
}
/// <summary>
/// Всплывающая подсказка, которая будет выведена при наведении курсора на
/// ячейку. Поле должно заполняться только при Reason=ToolTip.
/// В других режимах значение игнорируется. Перед вызовом события GetCellAttributes
/// вызывается событик GridColumn.ToolTipNeeded, таким образом, поле уже может
/// содержать значение.
/// Значение подсказки для строки не копируется в это поле. Можно использовать
/// значение RowToolTipText
/// </summary>
public string ToolTipText
{
get { return _ToolTipText; }
set
{
_ToolTipText = value;
_ToolTipTextHasBeenSet = true;
}
}
private string _ToolTipText;
internal bool ToolTipTextHasBeenSet { get { return _ToolTipTextHasBeenSet; } }
private bool _ToolTipTextHasBeenSet;
/// <summary>
/// Текст всплывающей подсказки для строки.
/// Свойство имеет значение только при Reason=ToolTip
/// Значение может быть использовано при формировании ToolTipText, чтобы
/// не вычислять текст еше раз, когда подсказка для ячеки основывается на подсказке
/// для строки
/// </summary>
public string RowToolTipText { get { return _RowToolTipText; } }
private string _RowToolTipText;
/// <summary>
/// Если установить в false, то содержимое ячейки не будет выводиться совсем.
/// Полезно для CheckBox'ов и кнопок, если для какой-то строки ячеек они не нужны
/// Скрытие работает для всех типов столбцов, включая DataGridViewTextBoxCell
/// </summary>
public bool ContentVisible { get { return _ContentVisible; } set { _ContentVisible = value; } }
private bool _ContentVisible;
#endregion
#region Защишенные методы
/// <summary>
/// Инициализация аргументов.
/// В первую очередь вызывает InitRow(), а затем инициализирует параметры для ячейки
/// </summary>
/// <param name="rowArgs">Аргументы вызванного ранее события EFPDataGridView.GetRowAttributes</param>
/// <param name="columnIndex">Индекс столбца DataGridViewColumn.Index</param>
/// <param name="cellStyle">Форматирование ячейки</param>
/// <param name="styleIsTemplate"></param>
/// <param name="originalValue"></param>
public void InitCell(EFPDataGridViewRowAttributesEventArgs rowArgs, int columnIndex, DataGridViewCellStyle cellStyle, bool styleIsTemplate, object originalValue)
{
base.InitRow(rowArgs.RowIndex, rowArgs.Reason);
_ColumnIndex = columnIndex;
_Column = ControlProvider.Columns[columnIndex];
ColorType = rowArgs.ColorType;
if (Column.ColorType > ColorType)
ColorType = Column.ColorType;
if (rowArgs._Grayed.HasValue)
_Grayed = rowArgs._Grayed.Value; // была явная установка свойства в обработчике строки
else if (Column.Grayed)
_Grayed = true;
else
_Grayed = null; // в принципе, это не нужно
TopBorder = rowArgs.TopBorder;
BottomBorder = rowArgs.BottomBorder;
if (Column.LeftBorder == EFPDataGridViewBorderStyle.Default)
LeftBorder = rowArgs.LeftBorder;
else
LeftBorder = Column.LeftBorder;
if (Column.RightBorder == EFPDataGridViewBorderStyle.Default)
RightBorder = rowArgs.RightBorder;
else
RightBorder = Column.RightBorder;
IndentLevel = 0;
if (styleIsTemplate)
{
_TemplateCellStyle = cellStyle;
_CellStyle = null;
}
else
{
_CellStyle = cellStyle;
_TemplateCellStyle = null;
}
_OriginalValue = originalValue;
ReadOnly = false;
ReadOnlyMessage = "Столбец предназначен только для просмотра";
if (Reason == EFPDataGridViewAttributesReason.ReadOnly)
{
DataGridViewRow GridRow = ControlProvider.Control.Rows[RowIndex]; // Unshared
ReadOnly = GridRow.Cells[columnIndex].ReadOnly;
// ReadOnly = ControlProvider.Control.Columns[ColumnIndex].ReadOnly;
}
ContentVisible = true;
if (!rowArgs.ControlContentVisible)
{
DataGridViewColumn GridCol = Control.Columns[columnIndex];
if (GridCol is DataGridViewCheckBoxColumn ||
GridCol is DataGridViewButtonColumn ||
GridCol is DataGridViewComboBoxColumn)
ContentVisible = false;
}
_RowToolTipText = rowArgs.ToolTipText;
ErrorMessageList CellErrors;
if (rowArgs.CellErrorMessages.TryGetValue(columnIndex, out CellErrors))
{
// if (CellErrors.Count > 0) - можно не проверять
switch (CellErrors.Severity)
{
case ErrorMessageKind.Error:
ColorType = EFPDataGridViewColorType.Error;
break;
case ErrorMessageKind.Warning:
if (ColorType != EFPDataGridViewColorType.Error)
ColorType = EFPDataGridViewColorType.Warning;
break;
// Для Info цвет не меняем
}
if (rowArgs.Reason == EFPDataGridViewAttributesReason.ToolTip)
{
for (int i = 0; i < CellErrors.Count; i++)
{
if (!String.IsNullOrEmpty(_RowToolTipText))
_RowToolTipText += Environment.NewLine;
_RowToolTipText += CellErrors[i];
}
}
}
_ToolTipTextHasBeenSet = false;
}
#endregion
}
#region Делегаты
/// <summary>
/// Делегат события EFPDataGridView.GetRowAttributes
/// </summary>
/// <param name="sender">Объект EFPDataGridView</param>
/// <param name="args">Аргументы события</param>
public delegate void EFPDataGridViewRowAttributesEventHandler(object sender,
EFPDataGridViewRowAttributesEventArgs args);
/// <summary>
/// Делегат события EFPDataGridView.GetCellAttributes
/// </summary>
/// <param name="sender">Объект EFPDataGridView</param>
/// <param name="args">Аргументы события</param>
public delegate void EFPDataGridViewCellAttributesEventHandler(object sender,
EFPDataGridViewCellAttributesEventArgs args);
#endregion
#endregion
#region EFPDataGridViewExcelCellAttributes
/// <summary>
/// В MS Excel нельзя использовать те же цвета, что и в табличном просмотре
/// на экране. Вместо этого можно использовать атрибуты шрифта
/// Метод EFPDataGridView.GetExcelCellAttr() позволяет получить атрибуты ячейки,
/// совместимые с Microsoft Excel
/// </summary>
[StructLayout(LayoutKind.Auto)]
public struct EFPDataGridViewExcelCellAttributes
{
#region Поля
/// <summary>
/// Цвет фона ячейки
/// Значение Color.Empty означает использование цвета фона по умолчанию ("Авто")
/// </summary>
public Color BackColor;
/// <summary>
/// Цвет текста
/// Значение Color.Empty означает использование цвета шрифта по умолчанию ("Авто")
/// </summary>
public Color ForeColor;
/// <summary>
/// Использовать жирный шрифт
/// </summary>
public bool Bold;
/// <summary>
/// Использовать наклонный шрифт
/// </summary>
public bool Italic;
/// <summary>
/// Использовать подчеркнутый шрифт
/// </summary>
public bool Underline;
#endregion
#region Дополнительные свойства
/// <summary>
/// Возвращает true, если никакие атрибцты не установлены
/// </summary>
public bool IsEmpty
{
get
{
return (!BackColor.IsEmpty) && (!ForeColor.IsEmpty) && (!Bold) && (!Italic) && (!Underline);
}
}
#endregion
}
#endregion
#region Режимы сохранения текущих строк
/// <summary>
/// Возможные способы сохранения / восстановления текущей позиции в табличном
/// просмотре (свойство EFPDataGridView.SelectedRowsMode)
/// </summary>
public enum EFPDataGridViewSelectedRowsMode
{
/// <summary>
/// Режим по умолчанию Текущая строка не может быть восстановлена
/// </summary>
None,
/// <summary>
/// Сохрание номеров строк.
/// Обычно подходит для табличных просмотров, не связанных с источником данных
/// </summary>
RowIndex,
/// <summary>
/// Сохранение ссылок на объекты DataRow
/// Подходит для просмотров, связанных с DataTable/DataView при условии, что
/// обновление таблицы не приводит к замене строк. Зато таблица может не иметь
/// ключевого поля.
/// </summary>
DataRow,
/// <summary>
/// Самый подходящий режим для просмотров, связанных с DataTable/DataView,
/// имеющих ключевое поле (или несколько полей, составляющих первичный ключ)
/// </summary>
PrimaryKey,
/// <summary>
/// Сохранение значений полей сортировки, заданных в свойстве DataView.ViewOrder
/// для объекта, связанного с табличным просмотром. Не следует использовать
/// этот режим, если в просмотре встречаются строки с одинаковыми значенями
/// полей (сортировка не обеспечивает уникальности)
/// </summary>
DataViewSort,
}
/// <summary>
/// Класс для сохранения текущей позиции и выбранных строк/столбцов в таблчном просмотре
/// (свойство EFPDataGridView.Selection)
/// Не содержит открытых полей
/// </summary>
public class EFPDataGridViewSelection
{
/// <summary>
/// Выбранные строки
/// </summary>
internal object SelectedRows;
/// <summary>
/// Текущая строка
/// </summary>
internal object CurrentRow;
/// <summary>
/// Режим "Выбраны все строки". В этом случае выбранные строки не запоминаются
/// </summary>
internal bool SelectAll;
/// <summary>
/// Номер текущего столбца
/// </summary>
internal int CurrentColumnIndex;
/// <summary>
/// true, если свойство DataGridView.DataSource было установлено
/// </summary>
internal bool DataSourceExists;
}
#endregion
#region Режимы установки отметок строк
/// <summary>
/// Аргумент RowList метода EFPDataGridView.CheckMarkRows()
/// </summary>
public enum EFPDataGridViewCheckMarkRows
{
/// <summary>
/// Для выбранных ячеек
/// </summary>
Selected,
/// <summary>
/// Для всех ячеек просмотра
/// </summary>
All
}
/// <summary>
/// Аргумент Action метода EFPDataGridView.CheckMarkRows()
/// </summary>
public enum EFPDataGridViewCheckMarkAction
{
/// <summary>
/// Установить флажки
/// </summary>
Check,
/// <summary>
/// Снять флажки
/// </summary>
Uncheck,
/// <summary>
/// Переключить состояние флажков на противоположное
/// </summary>
Invert
}
#endregion
#region Событие CellFinished
/// <summary>
/// Причина вызова события CellFinished
/// </summary>
public enum EFPDataGridViewCellFinishedReason
{
/// <summary>
/// Вызвано событие DataGridView.CellValueChanged в процессе редактирования ячейки
/// или значение вставлено из калькулятора
/// </summary>
Edit,
/// <summary>
/// Вставлено текстовое значение из буфера обмена с помощью EFPDataGridViewCommandItems.PerformPasteText()
/// </summary>
Paste,
/// <summary>
/// Значение очищено при вырезке текста ячеек в буфер обмена командой Cut
/// </summary>
Clear,
/// <summary>
/// Установка / снята отметка строки с помощью EFPDataGridView.CheckMarkRows()
/// </summary>
MarkRow,
}
/// <summary>
/// Аргументы события EFPDataGridView.CellFinished
/// </summary>
public class EFPDataGridViewCellFinishedEventArgs : EventArgs
{
#region Конструктор
/// <summary>
/// Создает аргументы события
/// </summary>
/// <param name="controlProvider">Провайдер табличного просмотра, вызвавшего событие</param>
/// <param name="rowIndex">Индекс строки</param>
/// <param name="columnIndex">Индекс строки</param>
/// <param name="reason">Причина появления события</param>
public EFPDataGridViewCellFinishedEventArgs(EFPDataGridView controlProvider, int rowIndex, int columnIndex,
EFPDataGridViewCellFinishedReason reason)
{
_ControlProvider = controlProvider;
_RowIndex = rowIndex;
_ColumnIndex = columnIndex;
_Reason = reason;
}
#endregion
#region Свойства
/// <summary>
/// Провайдер табличного просмотра, вызвавшего событие
/// </summary>
public EFPDataGridView ControlProvider { get { return _ControlProvider; } }
private EFPDataGridView _ControlProvider;
/// <summary>
/// Индекс строки
/// </summary>
public int RowIndex { get { return _RowIndex; } }
private int _RowIndex;
/// <summary>
/// Индекс строки
/// </summary>
public int ColumnIndex { get { return _ColumnIndex; } }
private int _ColumnIndex;
/// <summary>
/// Причина появления события
/// </summary>
public EFPDataGridViewCellFinishedReason Reason { get { return _Reason; } }
private EFPDataGridViewCellFinishedReason _Reason;
/// <summary>
/// Ячейка табличного просмотра
/// </summary>
public DataGridViewCell Cell
{
get { return _ControlProvider.Control[ColumnIndex, RowIndex]; }
}
/// <summary>
/// Строка данных, если табличный просмотр связан с таблицей DataTable.
/// Иначе возвращает null.
/// </summary>
public DataRow DataRow
{
get
{
return _ControlProvider.GetDataRow(RowIndex);
}
}
/// <summary>
/// Имя столбца табличного просмотра EFPDataGridViewColumn.Name.
/// </summary>
public string ColumnName { get { return _ControlProvider.Columns[ColumnIndex].Name; } }
#endregion
}
/// <summary>
/// Делегат события EFPDataGridView.CellFinished
/// </summary>
/// <param name="sender">Объект EFPDataGridView</param>
/// <param name="args">Аргументы события</param>
public delegate void EFPDataGridViewCellFinishedEventHandler(object sender,
EFPDataGridViewCellFinishedEventArgs args);
#endregion
#region Режимы подбора высоты строк
/// <summary>
/// Возможные значения свойства EFPDataGridView.AutoSizeRowsMode.
/// В текущей реализации существует единственный режим Auto.
/// </summary>
public enum EFPDataGridViewAutoSizeRowsMode
{
/// <summary>
/// Нет управления высотой строки или оно реализовано средствами DataGridView
/// </summary>
None,
/// <summary>
/// Выполняется автоподбор высоты отображаемых на экране строк
/// </summary>
Auto
}
#endregion
#region Интерфейс IEFPDataView
/// <summary>
/// Информация об одном столбце EFPDataGridView или EFPDataTreeView
/// </summary>
public struct EFPDataViewColumnInfo
{
#region Конструктор
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="dataPropertName"></param>
/// <param name="columnProducer"></param>
public EFPDataViewColumnInfo(string name, string dataPropertName, IEFPGridProducerColumn columnProducer)
{
_Name = name;
_DataPropertyName = dataPropertName;
_ColumnProducer = columnProducer;
}
#endregion
#region Свойства
/// <summary>
/// Имя столбца. Должно быть уникальным в пределах просмотра
/// </summary>
public string Name { get { return _Name; } }
private string _Name;
/// <summary>
/// Имя поля источника данных, если столбец отображает данные из источника.
/// Для вычисляемых столбцов содержит null
/// </summary>
public string DataPropertyName { get { return _DataPropertyName; } }
private string _DataPropertyName;
/// <summary>
/// Генератор столбца табличного просмотра. Null, если не использовался GridProducer.
/// </summary>
public IEFPGridProducerColumn ColumnProducer { get { return _ColumnProducer; } }
private IEFPGridProducerColumn _ColumnProducer;
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
return _Name;
}
#endregion
}
/// <summary>
/// Общие методы и свойства для EFPDataGridView и EFPDataTreeView
/// </summary>
public interface IEFPDataView : IEFPControl
{
/// <summary>
/// true, если просмотр предназначен только для просмотра, а не для редактирования данных
/// </summary>
bool ReadOnly { get; set; }
/// <summary>
/// Управляемое свойство для ReadOnly
/// </summary>
DepValue<bool> ReadOnlyEx { get; set; }
/// <summary>
/// true, если допускается создание новых записей.
/// Действует, если ReadOnly=false
/// </summary>
bool CanInsert { get; set; }
/// <summary>
/// Управляемое свойство для CanInsert
/// </summary>
DepValue<bool> CanInsertEx { get; set; }
/// <summary>
/// true, если допускается создание новых записей на основании существующей.
/// Действует, если ReadOnly=false, а CanInsert=true
/// </summary>
bool CanInsertCopy { get; set; }
/// <summary>
/// Управляемое свойство для CanInsertCopy
/// </summary>
DepValue<bool> CanInsertCopyEx { get; set; }
/// <summary>
/// true, если допускается удаление записей.
/// Действует, если ReadOnly=false
/// </summary>
bool CanDelete { get; set; }
/// <summary>
/// Управляемое свойство для CanDelete
/// </summary>
DepValue<bool> CanDeleteEx { get; set; }
/// <summary>
/// true, если допускается групповое редактирование и просмотр записей.
/// false, если допускается редактирование / просмотр только одной записи за раз.
/// Действует, если ReadOnly=false или CanView=true.
/// Не влияет на возможность удаления нескольких записей
/// </summary>
bool CanMultiEdit { get; set; }
/// <summary>
/// true, если возможен просмотр записей
/// </summary>
bool CanView { get; set; }
/// <summary>
/// Управляемое свойство для ReadOnly
/// </summary>
DepValue<bool> CanViewEx { get; set; }
/// <summary>
/// Возвращает источник данных в виде DataTable.
/// Возвращает null, если источник данных не является таблицей или просмотром таблицы
/// </summary>
DataTable SourceAsDataTable { get; }
/// <summary>
/// Возвращает источник данных в виде DataView.
/// Возвращает null, если источник данных не является таблицей или просмотром таблицы
/// </summary>
DataView SourceAsDataView { get; }
/// <summary>
/// Возвращает строку таблицы данных, соответствующую текущей строке / узлу
/// </summary>
DataRow CurrentDataRow { get; set; }
/// <summary>
/// Выбранные строки данных, если поддерживается множественный выбор.
/// Если допускается выбор только одной строки, то массив содержит значение свойства CurrentDataRow
/// </summary>
DataRow[] SelectedDataRows { get; set; }
/// <summary>
/// Проверяет, что в просмотре выбрана ровно одна строка.
/// Выдает сообщение, если это не так
/// </summary>
/// <returns>true, если выбрана одна строка</returns>
bool CheckSingleRow();
/// <summary>
/// Доступна ли для пользователя команда "Обновить просмотр".
/// Возвращает свойство CommandItems.UseRefresh.
/// В частности, для отчетов EFPReportDataGridViewPage возвращает false
/// </summary>
bool UseRefresh { get; }
/// <summary>
/// Выполняет обновление просмотра
/// </summary>
void PerformRefresh();
/// <summary>
/// Обновить все строки табличного просмотра.
/// В отличие от PerformRefresh(), обновляются только существующие строки, а не выполняется запрос к базе данных
/// </summary>
void InvalidateAllRows();
/// <summary>
/// Обновить в просмотре все выбранные строки SelectedRows, например, после
/// редактирования, если имеются вычисляемые столбцы
/// </summary>
void InvalidateSelectedRows();
/// <summary>
/// Пометить на обновление строку табличного просмотра, связанную с заданной строкой таблицы данных
/// </summary>
/// <param name="row">Строка связанной таблицы данных</param>
void InvalidateDataRow(DataRow row);
/// <summary>
/// Пометить на обновление строки табличного просмотра, связанные с заданными строками таблицы данных
/// </summary>
/// <param name="rows">Массив строк связанной таблицы данных</param>
void InvalidateDataRows(DataRow[] rows);
/// <summary>
/// Имя текущего столбца. Если выбрано несколько столбцов (например, строка целиком),
/// то пустая строка ("")
/// </summary>
string CurrentColumnName { get; }
}
#endregion
#region Интерфейс IEFPGridControl
/// <summary>
/// Интерфейс провайдера табличного просмотра.
/// Предназначен исключительно для использования в библиотеке ExtForms и ExtDBDocForms.
/// </summary>
public interface IEFPGridControl : IEFPControl
{
/// <summary>
/// Интерфейс для определения размеров элементов просмотра
/// </summary>
IEFPGridControlMeasures Measures { get; }
/// <summary>
/// Возвращает индекс текущего столбца просмотра или (-1), если выбрана вся строка
/// </summary>
int CurrentColumnIndex { get; }
/// <summary>
/// Текущая конфигурация столбцов просмотра
/// </summary>
EFPDataGridViewConfig CurrentConfig { get; set; }
/// <summary>
/// Генератор столбцов табличного просмотра
/// </summary>
IEFPGridProducer GridProducer { get; }
/// <summary>
/// Возвращает информацию о видимых столбцах
/// </summary>
/// <returns></returns>
EFPDataViewColumnInfo[] GetVisibleColumnsInfo();
/// <summary>
/// Должен заполнить в объекте EFPDataGridViewConfigColumn ширину и другие поля в сответствии с
/// реальной шириной в просмотре.
/// </summary>
/// <param name="configColumn">Заполняемая информация о столбце</param>
/// <returns>true, если столбец есть в просмотре и данные были заполнены</returns>
bool InitColumnConfig(EFPDataGridViewConfigColumn configColumn);
}
#endregion
/// <summary>
/// Провайдер табличного просмотра
/// </summary>
public class EFPDataGridView : EFPControl<DataGridView>, IEFPDataView, IEFPGridControl
{
#region Конструкторы
/// <summary>
/// Создает объект, привязанный к DataGridView
/// </summary>
/// <param name="baseProvider">Базовый провайдер</param>
/// <param name="control">Управляющий элемент Windows Forms</param>
public EFPDataGridView(EFPBaseProvider baseProvider, DataGridView control)
: base(baseProvider, control, true)
{
Init();
}
/// <summary>
/// Создает объект, привязанный к ControlWithToolBar
/// </summary>
/// <param name="controlWithToolBar">Управляющий элмент и панель инструментов</param>
public EFPDataGridView(IEFPControlWithToolBar<DataGridView> controlWithToolBar)
: base(controlWithToolBar, true)
{
Init();
}
private void Init()
{
Control.MultiSelect = false;
//Control.RowTemplate.Height = DefaultRowHeight;
Control.AllowUserToResizeRows = false;
Control.AllowUserToAddRows = false;
Control.AllowUserToDeleteRows = false;
Control.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
Control.StandardTab = true;
Control.DefaultCellStyle.ForeColor = SystemColors.WindowText; // 13.12.2017
Control.ShowCellToolTips = EFPApp.ShowToolTips; // 05.04.2018
_GetRowAttributesArgs = new EFPDataGridViewRowAttributesEventArgs(this);
_GetCellAttributesArgs = new EFPDataGridViewCellAttributesEventArgs(this);
Control_Leave(null, null);
_State = EFPDataGridViewState.View;
_ReadOnly = false;
_CanInsert = true;
_CanInsertCopy = false;
_CanDelete = true;
_CanView = true;
_CanMultiEdit = false;
_InsideEditData = false;
_CurrentColumnIndex = -1;
_CurrentIncSearchChars = String.Empty;
//FCurrentIncSearchMask = null;
_TextSearchContext = null;
_TextSearchEnabled = true;
_SelectedRowsMode = EFPDataGridViewSelectedRowsMode.None;
_OrderChangesToRefresh = false;
_AutoSort = false;
_UseGridProducerOrders = true;
_UseColumnHeaderClick = true;
_UseDefaultDataError = true;
if (!DesignMode)
{
Control.CurrentCellChanged += new EventHandler(Control_CurrentCellChanged);
Control.VisibleChanged += new EventHandler(Control_VisibleChanged);
Control.DataSourceChanged += new EventHandler(Control_DataBindingChanged);
Control.DataMemberChanged += new EventHandler(Control_DataBindingChanged);
Control.DataBindingComplete += new DataGridViewBindingCompleteEventHandler(Control_DataBindingComplete);
Control.KeyDown += new KeyEventHandler(Control_KeyDown);
Control.MouseDown += new MouseEventHandler(Control_MouseDown);
Control.RowPrePaint += new DataGridViewRowPrePaintEventHandler(Control_RowPrePaint);
Control.CellPainting += new DataGridViewCellPaintingEventHandler(Control_CellPainting);
Control.RowPostPaint += new DataGridViewRowPostPaintEventHandler(Control_RowPostPaint);
Control.CellFormatting += new DataGridViewCellFormattingEventHandler(Control_CellFormatting);
Control.Enter += new EventHandler(Control_Enter);
Control.Leave += new EventHandler(Control_Leave);
Control.KeyPress += new KeyPressEventHandler(Control_KeyPress);
Control.KeyDown += new KeyEventHandler(Control_KeyDown);
Control.CellClick += new DataGridViewCellEventHandler(Control_CellClick);
Control.CellContentClick += new DataGridViewCellEventHandler(Control_CellContentClick);
Control.CurrentCellDirtyStateChanged += new EventHandler(Control_CurrentCellDirtyStateChanged);
Control.CellValueChanged += new DataGridViewCellEventHandler(Control_CellValueChanged);
Control.CellParsing += new DataGridViewCellParsingEventHandler(Control_CellParsing);
Control.CellValidating += new DataGridViewCellValidatingEventHandler(Control_CellValidating);
Control.CellBeginEdit += new DataGridViewCellCancelEventHandler(Control_CellBeginEdit1);
//Control.CellEndEdit += new DataGridViewCellEventHandler(Control_CellEndEdit1);
Control.DataError += new DataGridViewDataErrorEventHandler(Control_DataError);
if (EFPApp.ShowToolTips)
{
//Control.VirtualMode = true; // Так нельзя. Перестает работать EFPErrorDataGridView и множество других просмотров без источников данных
Control.CellToolTipTextNeeded += new DataGridViewCellToolTipTextNeededEventHandler(Control_CellToolTipTextNeeded);
}
Control.ReadOnlyChanged += Control_ReadOnlyChanged;
}
base.UseIdle = true;
}
#endregion
#region Предотвращение мерцания при обновлении
private int _UpdateCount = 0;
private bool? _BeginUpdateVisible;
/// <summary>
/// Начать обновление данных табличного просмотра
/// </summary>
public void BeginUpdate()
{
// Так не работает, все равно все прыгает
// EFPDataGridView.SourceAsDataTable.BeginLoadData();
// EFPDatGridView.SourceAsDataTable.BeginInit();
if (_UpdateCount == 0)
{
if (WinFormsTools.AreControlAndFormVisible(Control) &&
ProviderState == EFPControlProviderState.Attached /* 15.07.2021 */)
{
_BeginUpdateVisible = Control.Visible;
Control.Visible = false;
}
else
_BeginUpdateVisible = null;
}
_UpdateCount++;
}
/// <summary>
/// Закончить обновление данных табличного просмотра
/// </summary>
public void EndUpdate()
{
if (_UpdateCount <= 0)
throw new InvalidOperationException("Не было вызова BeginUpdate");
_UpdateCount--;
if (_UpdateCount == 0)
{
if (_BeginUpdateVisible.HasValue)
Control.Visible = _BeginUpdateVisible.Value;
}
}
#endregion
#region Обработчики событий
/// <summary>
/// Этот метод вызывается после установки свойства CommandItems.Control
/// Добавляем обработчики, которые должны быть в конце цепочки
/// </summary>
internal protected virtual void AfterControlAssigned()
{
// Мы должны присоединить обработчик CellBeginEdit после пользовательского, т.к.
// нам нужно проверить свойство Cancel
Control.CellBeginEdit += new DataGridViewCellCancelEventHandler(Control_CellBeginEdit2);
Control.CellEndEdit += new DataGridViewCellEventHandler(Control_CellEndEdit2);
}
#region CurrentCellChanged
private bool _CurrentCellChangedFlag;
void Control_CurrentCellChanged(object sender, EventArgs args)
{
_CurrentCellChangedFlag = true;
}
/// <summary>
/// Вызывает при первом выводе таблицы на экран
/// </summary>
protected override void OnCreated()
{
// Должно быть до вызова метода базового класса
if (AutoSizeRowsMode == EFPDataGridViewAutoSizeRowsMode.Auto)
new EFPDataGridViewRowsResizer(this);
base.OnCreated();
_CurrentCellChangedFlag = true; // на случай, если с таблицей выполнялись манипуляции до показа на экране
if (UseColumnHeaderClick)
{
Control.ColumnHeaderMouseClick += new DataGridViewCellMouseEventHandler(Control_ColumnHeaderMouseClick);
Control.ColumnHeaderMouseDoubleClick += new DataGridViewCellMouseEventHandler(Control_ColumnHeaderMouseClick); // 04.07.2021
}
}
/// <summary>
/// Вызывает RefreshOrders()
/// </summary>
protected override void OnAttached()
{
base.OnAttached();
CommandItems.InitOrderItems();
InitColumnHeaderTriangles();
}
/// <summary>
/// Обработка сигнала Idle
/// </summary>
public override void HandleIdle()
{
base.HandleIdle();
if (_CurrentCellChangedFlag)
{
// обязательно до вызова CurrentCellChangedFlag.
// OnCurrentCellChanged() может установить флаг еще раз
_CurrentCellChangedFlag = false;
OnCurrentCellChanged();
}
if (_TopLeftCellToolTipTextUpdateFlag)
{
// Обновляем подсказку по числу строк
_TopLeftCellToolTipTextUpdateFlag = false;
TopLeftCellToolTipText = _TopLeftCellToolTipText;
}
}
/// <summary>
/// Вызывается при изменении текущей выбранной ячейки.
/// Вызывает обновление команд локального меню.
/// Предотвращается вложенный вызов метода
/// </summary>
protected virtual void OnCurrentCellChanged()
{
if (Control.Visible &&
(!_Inside_Control_DataBindingComplete) &&
Control.CurrentCellAddress.X >= 0 &&
//_VisibleHasChanged &&
_MouseOrKeyboardFlag)
_CurrentColumnIndex = Control.CurrentCellAddress.X;
// При смене текущего столбца отключаем поиск по первым буквам
if (CurrentIncSearchColumn != null)
{
if (CurrentIncSearchColumn.GridColumn.Index != Control.CurrentCellAddress.X)
CurrentIncSearchColumn = null;
}
// Обработка перемещений для установки видимости команд локального меню
CommandItems.PerformRefreshItems();
}
#endregion
#region VisibleChanged
///// <summary>
///// Только после установки этого флага разрешается реагировать на смену ячейки
///// </summary>
//public bool VisibleHasChanged { get { return _VisibleHasChanged; } }
//private bool _VisibleHasChanged;
/// <summary>
/// Этот флажок устанавливается в true, когда нажата мышь иди клавиша, что
/// означает, что просмотр есть на экране, и смена текущей ячейки выаолнена
/// пользователем
/// </summary>
private bool _MouseOrKeyboardFlag;
internal void Control_VisibleChanged(object sender, EventArgs args)
{
try
{
if (Control.Visible)
{
CurrentColumnIndex = CurrentColumnIndex;
if (Control.CurrentCell != null && Control.Height > 0 && Control.Width > 0)
{
if (!Control.CurrentCell.Displayed)
{
try
{
Control.FirstDisplayedCell = Control.CurrentCell;
}
catch
{
// Может быть InvalidOpertationException, если строки не помещаются
}
}
}
//CommandItems.RefreshStatItems();
}
//_VisibleHasChanged = Control.Visible;
_MouseOrKeyboardFlag = false;
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_VisibleChanged");
}
}
#endregion
#region DataBindingChanged
private void Control_DataBindingChanged(object sender, EventArgs args)
{
try
{
_SourceAsDataView = GetSourceAsDataView(Control.DataSource, Control.DataMember); // 04.07.2021
OnDataBindingChanged();
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка вызова OnDataBindingChanged()");
}
}
/// <summary>
/// Вызывается после изменения свойств DataSource или DataMember.
/// Если требуется выполнить действия после того, как инициализировано количество строк в просмотре,
/// используйте OnDataBindingComplete.
///
/// Если метод переопределен в классе-наследнике, обязательно должен быть вызван метод базового класса
/// </summary>
protected virtual void OnDataBindingChanged()
{
// 04.07.2021
// Делаем сортировку здесь, а не в OnDataBindingComplete(), чтобы избежать лишних действий
if (SourceAsDataView != null)
{
ValidateCurrentOrder();
if (AutoSort)
PerformAutoSort();
}
InitColumnSortMode();
}
#endregion
#region DataBindingComplete
/// <summary>
/// Событие DataBindingComplete может вызызываться вложенно из PerformAutoSort()
/// </summary>
private bool _Inside_Control_DataBindingComplete = false;
void Control_DataBindingComplete(object sender, DataGridViewBindingCompleteEventArgs args)
{
_TopLeftCellToolTipTextUpdateFlag = true; // число строк могло поменяться
if (args.ListChangedType != ListChangedType.Reset)
return;
if (_Inside_Control_DataBindingComplete)
return;
try
{
_Inside_Control_DataBindingComplete = true;
try
{
OnDataBindingComplete(args);
}
finally
{
_Inside_Control_DataBindingComplete = false;
}
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_DataBindingComplete");
}
}
/// <summary>
/// Вызывается при получении события DataGridView.DataBindingComplete.
/// Реентрантные события не вызывают метод.
/// </summary>
/// <param name="args">Аргументы события</param>
protected virtual void OnDataBindingComplete(DataGridViewBindingCompleteEventArgs args)
{
CurrentRowIndex = _SavedRowIndex;
if (args.ListChangedType == ListChangedType.Reset)
CurrentColumnIndex = CurrentColumnIndex;
_CurrentCellChangedFlag = true;
// После присоединения источника часто теряются треугольнички
// в заголовках строк
// 17.07.2021. Подтверждено.
// Если используется произвольная сортировка по двум столбцам, то первый треугольник рисуется, а второй - нет
if (args.ListChangedType == ListChangedType.Reset)
InitColumnHeaderTriangles();
}
#endregion
#region KeyDown
void Control_KeyDown(object sender, KeyEventArgs args)
{
try
{
_MouseOrKeyboardFlag = true;
DoControl_KeyDown2(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка обработки нажатия клавиши KeyDown");
}
}
#endregion
#region MouseDown
/// <summary>
/// При нажатии правой кнопки мыши на невыделенной ячейке надо поместить туда
/// выделение, а затем показывать локальное меню
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void Control_MouseDown(object sender, MouseEventArgs args)
{
try
{
DoControl_MouseDown(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_MouseDown");
}
}
void DoControl_MouseDown(MouseEventArgs args)
{
_MouseOrKeyboardFlag = true;
if (args.Button == MouseButtons.Right)
{
if (Control.AreAllCellsSelected(false))
return;
DataGridView.HitTestInfo ht = Control.HitTest(args.X, args.Y);
switch (ht.Type)
{
case DataGridViewHitTestType.Cell:
DataGridViewCell Cell = Control.Rows[ht.RowIndex].Cells[ht.ColumnIndex];
if (Cell.Selected)
return;
Control.ClearSelection();
Cell.Selected = true;
Control.CurrentCell = Cell;
break;
case DataGridViewHitTestType.RowHeader:
DataGridViewRow Row = Control.Rows[ht.RowIndex];
foreach (DataGridViewCell SelCell in Control.SelectedCells)
{
if (SelCell.RowIndex == ht.RowIndex)
return;
}
Control.ClearSelection();
Row.Selected = true;
int ColIdx = Control.CurrentCellAddress.X;
if (ColIdx < 0)
ColIdx = Control.FirstDisplayedScrollingColumnIndex;
if (ColIdx >= 0)
Control.CurrentCell = Row.Cells[ColIdx];
break;
case DataGridViewHitTestType.ColumnHeader:
DataGridViewColumn Column = Control.Columns[ht.ColumnIndex];
foreach (DataGridViewCell SelCell in Control.SelectedCells)
{
if (SelCell.ColumnIndex == ht.ColumnIndex)
return;
}
Control.ClearSelection();
Column.Selected = true;
int RowIdx = Control.CurrentCellAddress.Y;
if (RowIdx < 0)
RowIdx = Control.FirstDisplayedScrollingRowIndex;
if (RowIdx >= 0)
Control.CurrentCell = Control.Rows[RowIdx].Cells[ht.ColumnIndex];
break;
case DataGridViewHitTestType.TopLeftHeader:
if (Control.MultiSelect)
Control.SelectAll();
break;
}
}
}
#endregion
#endregion
#region Поиск текста
/// <summary>
/// Контекст поиска по Ctrl-F / F3.
/// Свойство возвращает null, если TextSearchEnabled=false
/// </summary>
public IEFPTextSearchContext TextSearchContext
{
get
{
if (_TextSearchEnabled)
{
if (_TextSearchContext == null)
_TextSearchContext = CreateTextSearchContext();
return _TextSearchContext;
}
else
return null;
}
}
private IEFPTextSearchContext _TextSearchContext;
/// <summary>
/// Создает объект EFPDataGridViewSearchContext.
/// Переопределенный метод может создать расширенный объект для поиска текста.
/// </summary>
/// <returns></returns>
protected virtual IEFPTextSearchContext CreateTextSearchContext()
{
return new EFPDataGridViewSearchContext(this);
}
/// <summary>
/// Если true (по умолчанию), то доступна команда "Найти" (Ctrl-F).
/// Если false, то свойство TextSearchContext возвращает null и поиск недоступен.
/// Свойство можно устанавливать только до вывода просмотра на экран
/// </summary>
public bool TextSearchEnabled
{
get { return _TextSearchEnabled; }
set
{
CheckHasNotBeenCreated();
_TextSearchEnabled = value;
}
}
private bool _TextSearchEnabled;
#endregion
#region GridProducer
/// <summary>
/// Генератор столбцов таблицы. Может устанавливаться только до показа табличного просмотра
/// На уровне EFPDataGridView используется при установке свойства CurrentConfig для инициализации
/// табличного просмотра.
/// </summary>
public IEFPGridProducer GridProducer
{
get { return _GridProducer; }
set
{
if (value != null)
value.SetReadOnly();
CheckHasNotBeenCreated();
Control.AutoGenerateColumns = false; // 10.03.2016
_GridProducer = value;
}
}
private IEFPGridProducer _GridProducer;
/// <summary>
/// Если свойство установлено в true (по умолчанию), то используется порядок сортировки строк, заданный в
/// GridProducer.
/// Если используется особая реализация просмотра, то можно отключить инициализацию порядка сортировки
/// строк, установив значение false. Установка допускается только до вывода просмотра на экран.
/// Как правило, при установке значения в false, следует также устанавливать CustomOrderAllowed=false.
/// </summary>
public bool UseGridProducerOrders
{
get { return _UseGridProducerOrders; }
set
{
CheckHasNotBeenCreated();
_UseGridProducerOrders = value;
}
}
private bool _UseGridProducerOrders;
#endregion
#region Другие свойства
/// <summary>
/// Текущее состояние просмотра.
/// Используется в событии EditData.
/// Свойство кратковременно устанавливается во время наступления события редактирования.
/// В остальное время имеет значение View.
/// </summary>
public EFPDataGridViewState State { get { return _State; } }
private EFPDataGridViewState _State;
/// <summary>
/// Размеры и масштабные коэффициенты для табличного просмотра
/// </summary>
public EFPDataGridViewMeasures Measures
{
get
{
if (_Measures == null)
_Measures = new EFPDataGridViewMeasures(this);
return _Measures;
}
}
private EFPDataGridViewMeasures _Measures;
IEFPGridControlMeasures IEFPGridControl.Measures { get { return Measures; } }
/// <summary>
/// Установка / получения высоты всех строк просмотра в единицах количества
/// строк текста, которые можно разместить в одной строке таблицы
/// </summary>
public int TextRowHeight
{
get
{
return Measures.GetTextRowHeight(Control.RowTemplate.Height);
}
set
{
int H = Measures.SetTextRowHeight(value);
Control.RowTemplate.Height = H;
}
}
#endregion
#region Управление поведением просмотра
#region ReadOnly
/// <summary>
/// true, если поддерживается только просмотр данных, а не редактирование.
/// Установка свойства отключает видимость всех команд редактирования.
/// Свойства CanInsert, CanDelete и CanInsertCopy перестают действовать
/// Значение по умолчанию: false (редактирование разрешено)
/// Не влияет на возможность inline-редактирования. Возможно любое сочетание
/// свойств ReadOnly и Control.ReadOnly
/// </summary>
[DefaultValue(false)]
public bool ReadOnly
{
get { return _ReadOnly; }
set
{
if (value == _ReadOnly)
return;
_ReadOnly = value;
if (_ReadOnlyEx != null)
_ReadOnlyEx.Value = value;
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
}
private bool _ReadOnly;
/// <summary>
/// Управляемое свойство для ReadOnly.
/// </summary>
public DepValue<bool> ReadOnlyEx
{
get
{
InitReadOnlyEx();
return _ReadOnlyEx;
}
set
{
InitReadOnlyEx();
_ReadOnlyEx.Source = value;
}
}
private DepInput<bool> _ReadOnlyEx;
private void InitReadOnlyEx()
{
if (_ReadOnlyEx == null)
{
_ReadOnlyEx = new DepInput<bool>(ReadOnly, ReadOnlyEx_ValueChanged);
_ReadOnlyEx.OwnerInfo = new DepOwnerInfo(this, "ReadOnlyEx");
}
}
void ReadOnlyEx_ValueChanged(object Sender, EventArgs Args)
{
ReadOnly = _ReadOnlyEx.Value;
}
#endregion
#region CanInsert
/// <summary>
/// true, если можно добаввлять строки (при DataReadOnly=false)
/// Значение по умолчанию: true (добавление строк разрешено)
/// </summary>
[DefaultValue(true)]
public bool CanInsert
{
get { return _CanInsert; }
set
{
if (value == _CanInsert)
return;
_CanInsert = value;
if (_CanInsertEx != null)
_CanInsertEx.Value = value;
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
}
private bool _CanInsert;
/// <summary>
/// Управляемое свойство для CanInsert
/// </summary>
public DepValue<bool> CanInsertEx
{
get
{
InitCanInsertEx();
return _CanInsertEx;
}
set
{
InitCanInsertEx();
_CanInsertEx.Source = value;
}
}
private DepInput<bool> _CanInsertEx;
private void InitCanInsertEx()
{
if (_CanInsertEx == null)
{
_CanInsertEx = new DepInput<bool>(CanInsert, CanInsertEx_ValueChanged);
_CanInsertEx.OwnerInfo = new DepOwnerInfo(this, "CanInsertEx");
}
}
void CanInsertEx_ValueChanged(object Sender, EventArgs Args)
{
CanInsert = _CanInsertEx.Value;
}
#endregion
#region CanInsertCopy
/// <summary>
/// true, если разрешено добавлять строку по образцу существующей
/// (при DataReadOnly=false и CanInsert=true)
/// Значение по умолчанию: false (копирование запрещено)
/// </summary>
[DefaultValue(false)]
public bool CanInsertCopy
{
get { return _CanInsertCopy; }
set
{
if (value == _CanInsertCopy)
return;
_CanInsertCopy = value;
if (_CanInsertCopyEx != null)
_CanInsertCopyEx.Value = value;
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
}
private bool _CanInsertCopy;
/// <summary>
/// Управляемое свойство для Checked.
/// </summary>
public DepValue<bool> CanInsertCopyEx
{
get
{
InitCanInsertCopyEx();
return _CanInsertCopyEx;
}
set
{
InitCanInsertCopyEx();
_CanInsertCopyEx.Source = value;
}
}
private DepInput<bool> _CanInsertCopyEx;
private void InitCanInsertCopyEx()
{
if (_CanInsertCopyEx == null)
{
_CanInsertCopyEx = new DepInput<bool>(CanInsertCopy, CanInsertCopyEx_ValueChanged);
_CanInsertCopyEx.OwnerInfo = new DepOwnerInfo(this, "CanInsertCopyEx");
}
}
void CanInsertCopyEx_ValueChanged(object Sender, EventArgs Args)
{
CanInsertCopy = _CanInsertCopyEx.Value;
}
#endregion
#region CanDelete
/// <summary>
/// true, если можно удалять строки (при DataReadOnly=false)
/// Значение по умолчанию: true (удаление разрешено)
/// </summary>
[DefaultValue(true)]
public bool CanDelete
{
get { return _CanDelete; }
set
{
if (value == _CanDelete)
return;
_CanDelete = value;
if (_CanDeleteEx != null)
_CanDeleteEx.Value = value;
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
}
private bool _CanDelete;
/// <summary>
/// Управляемое свойство для CanDelete.
/// </summary>
public DepValue<bool> CanDeleteEx
{
get
{
InitCanDeleteEx();
return _CanDeleteEx;
}
set
{
InitCanDeleteEx();
_CanDeleteEx.Source = value;
}
}
private DepInput<bool> _CanDeleteEx;
private void InitCanDeleteEx()
{
if (_CanDeleteEx == null)
{
_CanDeleteEx = new DepInput<bool>(CanDelete, CanDeleteEx_ValueChanged);
_CanDeleteEx.OwnerInfo = new DepOwnerInfo(this, "CanDeleteEx");
}
}
void CanDeleteEx_ValueChanged(object Sender, EventArgs Args)
{
CanDelete = _CanDeleteEx.Value;
}
#endregion
#region CanView
/// <summary>
/// true, если можно просмотреть выбранные строки в отдельном окне
/// По умолчанию: true
/// </summary>
[DefaultValue(true)]
public bool CanView
{
get { return _CanView; }
set
{
if (value == _CanView)
return;
_CanView = value;
if (_CanViewEx != null)
_CanViewEx.Value = value;
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
}
private bool _CanView;
/// <summary>
/// Управляемое свойство для CanView.
/// </summary>
public DepValue<bool> CanViewEx
{
get
{
InitCanViewEx();
return _CanViewEx;
}
set
{
InitCanViewEx();
_CanViewEx.Source = value;
}
}
private DepInput<bool> _CanViewEx;
private void InitCanViewEx()
{
if (_CanViewEx == null)
{
_CanViewEx = new DepInput<bool>(CanView, CanViewEx_ValueChanged);
_CanViewEx.OwnerInfo = new DepOwnerInfo(this, "CanViewEx");
}
}
void CanViewEx_ValueChanged(object Sender, EventArgs Args)
{
CanView = _CanViewEx.Value;
}
#endregion
/// <summary>
/// true, если разрешено редактирование и просмотр одновременно
/// нескольких выбранных строк
/// По умолчанию - false
/// </summary>
[DefaultValue(false)]
public bool CanMultiEdit
{
get
{
return _CanMultiEdit;
}
set
{
_CanMultiEdit = value;
if (value)
Control.MultiSelect = true;
}
}
private bool _CanMultiEdit;
/// <summary>
/// Блокировка сортировки для всех столбцов
/// Для столбцов, определенных в Orders, сортировка остается разрешенной
/// </summary>
public void DisableOrdering()
{
for (int i = 0; i < Control.Columns.Count; i++)
Control.Columns[i].SortMode = DataGridViewColumnSortMode.NotSortable;
// 03.06.2011
// Для столбцов, установленных в Orders, разрешаем сортировку
if (OrderCount > 0)
{
for (int i = 0; i < Orders.Count; i++)
{
int ColumnIndex = IndexOfUsedColumnName(Orders[i]);
if (ColumnIndex >= 0)
Control.Columns[ColumnIndex].SortMode = DataGridViewColumnSortMode.Programmatic;
}
}
}
#if XXX
// бессмыслено
/// <summary>
/// Возвращает свойство DataGridView.ReadOnly.
/// При установке свойства, в отличие от оригинального, сохраняются существующие
/// значения свойства "ReadOnly" для всех столбцов
/// </summary>
public bool ControlReadOnly
{
get { return Control.ReadOnly; }
set
{
if (value == Control.ReadOnly)
return;
bool[] Flags = new bool[Control.ColumnCount];
for (int i = 0; i < Control.ColumnCount; i++)
Flags[i] = Control.Columns[i].ReadOnly;
Control.ReadOnly = value;
for (int i = 0; i < Control.ColumnCount; i++)
Control.Columns[i].ReadOnly = Flags[i];
}
}
#endif
/// <summary>
/// Установить свойство DataReadOnly для всех столбцов просмотра.
/// Метод используется, когда требуется разрешить редактирование "по месту"
/// только для некоторых столбцов, а большая часть столбцов не редактируется
/// Метод должен вызываться после установки общих свойств DataReadOnly табличного
/// просмотра, иначе признак у столбцов может быть изменен неявно
/// </summary>
/// <param name="value">Устанавливаемое значение</param>
public void SetColumnsReadOnly(bool value)
{
for (int i = 0; i < Control.Columns.Count; i++)
Control.Columns[i].ReadOnly = value;
}
/// <summary>
/// Установить свойство DataReadOnly для заданных столбцов просмотра.
/// Метод используется, когда требуется разрешить редактирование "по месту"
/// только для некоторых столбцов, а большая часть столбцов не редактируется
/// Метод должен вызываться после установки общих свойств DataReadOnly табличного
/// просмотра, иначе признак у столбцов может быть изменен неявно
/// </summary>
/// <param name="columnNames">Список имен столбцов через запятую. Если столбец с заданным именем не найден, то ошибка не выдается</param>
/// <param name="value">Устанавливаемое значение</param>
public void SetColumnsReadOnly(string columnNames, bool value)
{
string[] a = columnNames.Split(',');
for (int i = 0; i < a.Length; i++)
{
EFPDataGridViewColumn Col = Columns[a[i]];
if (Col != null)
Col.GridColumn.ReadOnly = value;
}
}
void Control_ReadOnlyChanged(object sender, EventArgs args)
{
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
#endregion
#region Список столбцов
/// <summary>
/// Дополнительная информация о столбцах, альтернативные методы добавления
/// столбцов
/// </summary>
public EFPDataGridViewColumns Columns
{
get
{
if (_Columns == null)
_Columns = CreateColumns();
return _Columns;
}
}
private EFPDataGridViewColumns _Columns;
/// <summary>
/// Создает EFPDataGridViewColumns.
/// </summary>
/// <returns>Новый объект</returns>
protected virtual EFPDataGridViewColumns CreateColumns()
{
return new EFPDataGridViewColumns(this);
}
EFPDataViewColumnInfo[] IEFPGridControl.GetVisibleColumnsInfo()
{
EFPDataGridViewColumn[] RealColumns = VisibleColumns;
EFPDataViewColumnInfo[] a = new EFPDataViewColumnInfo[RealColumns.Length];
for (int i = 0; i < RealColumns.Length; i++)
a[i] = new EFPDataViewColumnInfo(RealColumns[i].Name, RealColumns[i].GridColumn.DataPropertyName, RealColumns[i].ColumnProducer);
return a;
}
bool IEFPGridControl.InitColumnConfig(EFPDataGridViewConfigColumn configColumn)
{
EFPDataGridViewColumn Col = Columns[configColumn.ColumnName];
if (Col == null)
return false;
DataGridViewColumn GridCol = Col.GridColumn;
configColumn.Width = GridCol.Width;
configColumn.FillMode = GridCol.AutoSizeMode == DataGridViewAutoSizeColumnMode.Fill;
configColumn.FillWeight = (int)(GridCol.FillWeight);
return true;
}
#endregion
#region Доступ к выбранным ячейкам независимо от типа данных
/// <summary>
/// Сколько строк выбрано сейчас в просмотре (одна, много или ни одной)
/// Для точного определения используйте свойство SelectedRows.
/// В отличие от SelectedRows метод вычисляется всегда быстро
/// </summary>
public EFPDataGridViewSelectedRowsState SelectedRowsState
{
get
{
if ((Control.SelectionMode == DataGridViewSelectionMode.FullRowSelect) ||
Control.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect)
{
if (Control.SelectedRows.Count > 0)
{
return Control.SelectedRows.Count > 1 ? EFPDataGridViewSelectedRowsState.MultiRows :
EFPDataGridViewSelectedRowsState.SingleRow;
}
// Иначе придется определять с помощью SelectedCells
if (Control.SelectedCells.Count > 0)
{
int FirstIndex = Control.SelectedCells[0].RowIndex;
for (int i = 1; i < Control.SelectedCells.Count; i++)
{
if (Control.SelectedCells[i].RowIndex != FirstIndex)
return EFPDataGridViewSelectedRowsState.MultiRows;
}
return EFPDataGridViewSelectedRowsState.SingleRow;
}
}
if (Control.CurrentRow == null)
return EFPDataGridViewSelectedRowsState.NoSelection;
return EFPDataGridViewSelectedRowsState.SingleRow;
}
}
/// <summary>
/// Возвращает true, если в просмотре есть хотя бы одна выбранная ячейка
/// </summary>
public bool HasSelectedRows
{
get
{
return Control.SelectedRows.Count > 0 || Control.SelectedCells.Count > 0 || Control.CurrentRow != null;
}
}
/// <summary>
/// Возвращает true, если в просмотре выбраны целые строки
/// </summary>
public bool WholeRowsSelected
{
get
{
if (Control.AreAllCellsSelected(false))
return true;
return Control.SelectedRows != null && Control.SelectedRows.Count > 0;
}
}
/// <summary>
/// Внутренний класс для реализации сравнения
/// </summary>
private class RCComparer : IComparer<DataGridViewRow>, IComparer<DataGridViewColumn>
{
#region IComparer<DataGridViewRow> Members
/// <summary>
/// Сравнение двух строк для сортировки
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public int Compare(DataGridViewRow x, DataGridViewRow y)
{
if (x == null)
{
if (y == null)
return 0;
else
return -1;
}
if (y == null)
return 1;
if (x.Index == y.Index)
return 0;
if (x.Index > y.Index)
return 1;
else
return -1;
}
#endregion
#region IComparer<DataGridViewColumn> Members
/// <summary>
/// Сравнение двух столбцов для сортировки в порядке их отображения на экране
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public int Compare(DataGridViewColumn x, DataGridViewColumn y)
{
if (x == null)
{
if (y == null)
return 0;
else
return -1;
}
if (y == null)
return 1;
if (x.DisplayIndex == y.DisplayIndex)
{
if (x.Index == y.Index)
return 0;
if (x.Index > y.Index)
return 1;
else
return -1;
}
if (x.DisplayIndex > y.DisplayIndex)
return 1;
else
return -1;
}
#endregion
#region Методы сортировки
/// <summary>
/// Сортировка массива строк в соответствии с их порядком на экране
/// </summary>
/// <param name="rows"></param>
public void SortGridRows(DataGridViewRow[] rows)
{
Array.Sort<DataGridViewRow>(rows, this);
}
#endregion
}
/// <summary>
/// Реализация сортировки строк и столбцов
/// </summary>
private static readonly RCComparer _TheRCComparer = new RCComparer();
/// <summary>
/// Получить или установить выделенные строки таблицы. В режиме выделения
/// ячейки, а не целой строки, возвращается массив из одного элемента
/// </summary>
public DataGridViewRow[] SelectedGridRows
{
get
{
return GetSelectedGridRows(Control);
}
set
{
if (value == null)
return; // 27.12.2020
if (value.Length == 0)
return;
bool FirstRowFlag = true;
switch (Control.SelectionMode)
{
case DataGridViewSelectionMode.FullRowSelect:
// Режим выбора только целых строк
Control.ClearSelection();
for (int i = 0; i < value.Length; i++)
{
//if (value != null)
if (value[i] != null) // 27.12.2020
{
if (FirstRowFlag)
{
CurrentGridRow = value[i];
FirstRowFlag = false;
}
value[i].Selected = true;
}
}
break;
case DataGridViewSelectionMode.RowHeaderSelect:
// В этом режиме можно либо выбирать целые строки, либо ячейки
if (Control.SelectedRows.Count > 0)
{
// До этого были выбраны строки, делаем также
Control.ClearSelection();
for (int i = 0; i < value.Length; i++)
{
if (value[i] != null)
{
if (FirstRowFlag)
{
CurrentGridRow = value[i];
FirstRowFlag = false;
}
value[i].Selected = true;
}
}
}
else
{
// До этого была выбрана одна ячейка. Выбираем строки, если их
// несколько или выбираем ячейку, если она одна
if (value.Length > 1)
{
for (int i = 0; i < value.Length; i++)
{
if (FirstRowFlag)
{
CurrentGridRow = value[i];
FirstRowFlag = false;
}
if (value[i] != null)
value[i].Selected = true;
}
}
else
{
if (value[0] != null)
CurrentGridRow = value[0];
}
}
break;
default:
// Просмотр не в режиме выбора строк. Очищаем выбор и делаем текущей
// первую строку из набора
Control.ClearSelection();
if (value[0] != null)
CurrentGridRow = value[0];
break;
}
_CurrentCellChangedFlag = true;
}
}
private static DataGridViewRow[] GetSelectedGridRows(DataGridView control)
{
DataGridViewRow[] res;
if ((control.SelectionMode == DataGridViewSelectionMode.FullRowSelect) ||
control.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect)
{
if (control.SelectedRows.Count > 0)
{
res = new DataGridViewRow[control.SelectedRows.Count];
control.SelectedRows.CopyTo(res, 0);
_TheRCComparer.SortGridRows(res);
return res;
}
if (control.SelectedCells.Count > 0)
{
// Собираем строки для выбранных ячеек
List<DataGridViewRow> Rows = new List<DataGridViewRow>();
foreach (DataGridViewCell Cell in control.SelectedCells)
{
DataGridViewRow ThisRow = Cell.OwningRow;
if (!Rows.Contains(ThisRow))
Rows.Add(ThisRow);
}
res = Rows.ToArray();
_TheRCComparer.SortGridRows(res);
return res;
}
}
if (control.CurrentRow == null)
return new DataGridViewRow[0];
res = new DataGridViewRow[1];
res[0] = control.CurrentRow;
return res;
}
/// <summary>
/// Вспомогательное свойство. Возвращает число выбранных строк в просмотре.
/// Оптимальнее, чем вызов SelectedRows.Length
/// </summary>
public int SelectedRowCount
{
get
{
if (Control.AreAllCellsSelected(true))
return Control.RowCount;
else
{
if ((Control.SelectionMode == DataGridViewSelectionMode.FullRowSelect) ||
Control.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect)
{
if (Control.SelectedRows.Count > 0)
return Control.SelectedRows.Count;
if (Control.SelectedCells.Count > 0)
{
// Собираем строки для выбранных ячеек
List<DataGridViewRow> Rows = new List<DataGridViewRow>();
foreach (DataGridViewCell Cell in Control.SelectedCells)
{
DataGridViewRow ThisRow = Cell.OwningRow;
if (!Rows.Contains(ThisRow))
Rows.Add(ThisRow);
}
return Rows.Count;
}
}
if (Control.CurrentRow == null)
return 0;
return 1;
}
}
}
/// <summary>
/// Оригинальное свойство DataGridView.CurrentRow не позволяет
/// установить позицию.
/// </summary>
public DataGridViewRow CurrentGridRow
{
get
{
return Control.CurrentRow;
}
set
{
if (value == null)
return;
int ColIdx = CurrentColumnIndex;
if (ColIdx < 0 || ColIdx >= Control.Columns.Count /* 21.11.2018 */)
ColIdx = 0;
Control.CurrentCell = value.Cells[ColIdx];
}
}
/// <summary>
/// Эквивалентно установке свойства CurrentGridRow, но в просмотре выделяется,
/// если возможно, строка целиком
/// </summary>
/// <param name="row"></param>
void SelectGridRow(DataGridViewRow row)
{
if (row == null)
return;
// Установка ячейки
CurrentGridRow = row;
if ((Control.SelectionMode == DataGridViewSelectionMode.FullRowSelect) ||
Control.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect)
{
// Выделение целой строки
Control.ClearSelection();
row.Selected = true;
}
}
/// <summary>
/// Расширение свойства SelectedRows. Вместо объекта DataGridViewRow
/// используются индексы строк
/// </summary>
public int[] SelectedRowIndices
{
get
{
return GetSelectedRowIndices(Control);
}
set
{
DataGridViewRow[] Rows = new DataGridViewRow[value.Length];
for (int i = 0; i < value.Length; i++)
{
if (value[i] >= 0 && value[i] < Control.Rows.Count)
Rows[i] = Control.Rows[value[i]];
}
SelectedGridRows = Rows;
}
}
private static int[] GetSelectedRowIndices(DataGridView control)
{
DataGridViewRow[] Rows = GetSelectedGridRows(control);
int[] res = new int[Rows.Length];
for (int i = 0; i < Rows.Length; i++)
{
if (Rows[i] == null)
res[i] = -1;
else
res[i] = Rows[i].Index;
}
return res;
}
/// <summary>
/// Расширение свойства CurrentRow. Вместо объекта DataGridViewRow
/// используется индекс строки
/// </summary>
public int CurrentRowIndex
{
get
{
DataGridViewRow Row = CurrentGridRow;
if (Row == null)
return -1;
else
return Row.Index;
}
set
{
if (Control.Rows.Count == 0)
{
_SavedRowIndex = value;
return;
}
if (value >= 0 && value < Control.Rows.Count)
CurrentGridRow = Control.Rows[value];
_SavedRowIndex = -1;
}
}
private int _SavedRowIndex = -1;
/// <summary>
/// Выделяет строку в просмотре с заданыым индексом.
/// Используйте установку свойства CurrentRowIndex
/// </summary>
/// <param name="rowIndex"></param>
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public void SelectRowIndex(int rowIndex)
{
if (Control.Rows.Count == 0)
{
_SavedRowIndex = rowIndex;
return;
}
if (rowIndex >= 0 && rowIndex < Control.Rows.Count)
SelectGridRow(Control.Rows[rowIndex]);
_SavedRowIndex = -1;
}
/// <summary>
/// Получить выделенные столбцы таблицы. В режиме выделения
/// ячейки возвращается массив из одного элемента. В режиме выбора строк
/// возвращается массив всех видимых столбцов
/// </summary>
public DataGridViewColumn[] SelectedGridColumns
{
get
{
return GetSelectedGridColumns(Control);
}
}
private static DataGridViewColumn[] GetSelectedGridColumns(DataGridView control)
{
if (control.AreAllCellsSelected(false))
return WinFormsTools.GetOrderedVisibleColumns(control);
if (control.SelectedColumns != null && control.SelectedColumns.Count > 0)
{
// Есть выбранные целые столбцы
DataGridViewColumn[] res = new DataGridViewColumn[control.SelectedColumns.Count];
for (int i = 0; i < control.SelectedColumns.Count; i++)
res[i] = control.SelectedColumns[i];
return res;
}
if (control.SelectedCells != null && control.SelectedCells.Count > 0)
{
// Есть отдельные выбранные ячейки
List<DataGridViewColumn> res = new List<DataGridViewColumn>();
foreach (DataGridViewCell Cell in control.SelectedCells)
{
DataGridViewColumn Col = control.Columns[Cell.ColumnIndex];
if (res.IndexOf(Col) < 0)
{
res.Add(Col);
if (res.Count == control.ColumnCount)
break; // найдены все столбцы
}
}
res.Sort(_TheRCComparer);
return res.ToArray();
}
if (control.SelectedRows != null && control.SelectedRows.Count > 0)
{
// Есть целиком выбранные строки - возвращаем все видимые столбцы
return WinFormsTools.GetOrderedVisibleColumns(control);
}
if (control.CurrentCellAddress.X >= 0)
// Есть только выделенная ячейка
return new DataGridViewColumn[1] { control.Columns[control.CurrentCellAddress.X] };
// Нет выделенной ячейки
return new DataGridViewColumn[0];
}
/// <summary>
/// Возвращает массив индексов выделенных столбов просмотра.
/// </summary>
public int[] SelectedColumnIndices
{
get
{
return GetSelectedColumnIndices(Control);
}
}
private static int[] GetSelectedColumnIndices(DataGridView control)
{
DataGridViewColumn[] Cols = GetSelectedGridColumns(control);
int[] indices = new int[Cols.Length];
for (int i = 0; i < Cols.Length; i++)
indices[i] = Cols[i].Index;
return indices;
}
/// <summary>
/// Получить выделенные столбцы таблицы. В режиме выделения
/// ячейки возвращается массив из одного элемента. В режиме выбора строк
/// возвращается массив всех видимых столбцов
/// </summary>
public EFPDataGridViewColumn[] SelectedColumns
{
get
{
DataGridViewColumn[] Cols = SelectedGridColumns;
EFPDataGridViewColumn[] Cols2 = new EFPDataGridViewColumn[Cols.Length];
for (int i = 0; i < Cols.Length; i++)
Cols2[i] = Columns[Cols[i]];
return Cols2;
}
}
/// <summary>
/// Возвращает true, если ячейка является выбранной, находится в выбранной
/// целиком строке или столбце.
/// </summary>
/// <param name="rowIndex">Индекс строки</param>
/// <param name="columnIndex">Индекс столбца</param>
/// <returns>true, если ячейка является текущей, выбранной индивидуально или в составе выделенной строки или столбца</returns>
public bool IsCellSelected(int rowIndex, int columnIndex)
{
if (rowIndex < 0 || rowIndex >= Control.RowCount)
return false;
if (columnIndex < 0 || columnIndex >= Control.Columns.Count)
return false;
if (!Control.Rows.SharedRow(rowIndex).Visible)
return false;
if (!Control.Columns[columnIndex].Visible)
return false;
if (Control.AreAllCellsSelected(false))
return true;
if (Control.SelectedCells != null && Control.SelectedCells.Count > 0)
{
DataGridViewCell Cell = Control[columnIndex, rowIndex];
return Control.SelectedCells.Contains(Cell);
}
if (Control.SelectedRows != null && Control.SelectedRows.Count > 0)
{
DataGridViewRow Row = Control.Rows[rowIndex];
return Control.SelectedRows.Contains(Row);
}
if (Control.SelectedColumns != null && Control.SelectedColumns.Count > 0)
{
DataGridViewColumn Col = Control.Columns[columnIndex];
return Control.SelectedColumns.Contains(Col);
}
return Control.CurrentCellAddress.X == columnIndex && Control.CurrentCellAddress.Y == rowIndex;
}
/// <summary>
/// Вспомогательное свойство только для чтения. Возвращает true, если свойство
/// CurrentRow установлено (в просмотре есть текущая строка) и она является
/// единственной выбранной строкой
/// </summary>
public bool IsCurrentRowSingleSelected
{
get
{
DataGridViewRow TheRow = CurrentGridRow; // самое простое свойство
if (TheRow == null)
return false; // нет текущей строки совсем
if ((Control.SelectionMode == DataGridViewSelectionMode.FullRowSelect) ||
Control.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect)
{
// Проверяем наличие других выбранных строк
if (Control.SelectedRows.Count > 0)
{
for (int i = 0; i < Control.SelectedRows.Count; i++)
{
if (Control.SelectedRows[i] != TheRow)
return false; // Нашли другую строку
}
}
}
// Проверяем наличие выделенных ячеек от других строк
if (Control.SelectedCells.Count > 0)
{
for (int i = 0; i < Control.SelectedCells.Count; i++)
{
if (Control.SelectedCells[i].OwningRow != TheRow)
return false;
}
}
return true;
}
}
/// <summary>
/// Выбор прямоугольной области ячеек
/// Свойство возвращает/устанавливает выбранные строки и столбцы в виде
/// координат прямоугольника
/// </summary>
public Rectangle SelectedRectAddress
{
get
{
if (Control.AreAllCellsSelected(false))
return new Rectangle(0, 0, Control.ColumnCount, Control.RowCount);
int[] Rows = SelectedRowIndices;
int[] Cols = SelectedColumnIndices;
if (Rows.Length == 0 || Cols.Length == 0)
return Rectangle.Empty;
int x1 = Cols[0];
int x2 = Cols[Cols.Length - 1];
int y1 = Rows[0];
int y2 = Rows[Rows.Length - 1];
return new Rectangle(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
}
set
{
throw new BugException("Не реализовано");
}
}
/// <summary>
/// Вспомогательный метод
/// Возвращает true, если в просмотре есть только одна выбранная (текущая) строка
/// Если в просмотре нет текущей строки или выбрано больше одной строки, то
/// выдается соответствующее сообщение с помошью EFPApp.ShowTempMessage().
/// Возвращаемое значение соответствует свойству IsCurrentRowSingleSelected
/// Используйте метод для упрощения реализации методов редактирования или команд
/// локального меню, если они должны работать с единственной строкой. После
/// вызова метода используйте одно из свойств CurrentXxxRow для доступа к строке
/// </summary>
/// <returns></returns>
public bool CheckSingleRow()
{
if (CurrentGridRow == null)
{
EFPApp.ShowTempMessage("В табличном просмотре нет выбранной строки");
return false;
}
if (!IsCurrentRowSingleSelected)
{
EFPApp.ShowTempMessage("В табличном просмотре выбрано больше одной строки");
return false;
}
return true;
}
/// <summary>
/// Перечислитель по выбранным ячейкам таблицы для всех режимов.
/// Элементом перечисления является структура Point, содержащая индекс строки (Y) и столбца (X)
/// очередной ячейки.
/// Скрытые строки и столбцы не учитываются.
/// Правильно обрабатываются и сложно выбранные ячейки.
/// </summary>
public sealed class SelectedCellAddressEnumerable : IEnumerable<Point>
{
#region Конструктор
internal SelectedCellAddressEnumerable(DataGridView control)
{
_Control = control;
}
private DataGridView _Control;
#endregion
#region IEnumerable<Point> Members
/// <summary>
/// Создает перечислитель
/// </summary>
/// <returns>Перечислитель</returns>
public IEnumerator<Point> GetEnumerator()
{
if (_Control.AreAllCellsSelected(false))
return GetAllCellsEnumerator();
if (_Control.SelectedRows.Count > 0 || _Control.SelectedColumns.Count > 0 || _Control.SelectedCells.Count > 0)
return GetSelectedEnumerator();
// нельзя здесь сделать yeld return
return GetCurrentCellEnumerator();
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
#region Выбраны все ячейки
private IEnumerator<Point> GetAllCellsEnumerator()
{
int[] ColIdxs = EFPDataGridView.GetSelectedColumnIndices(_Control); // все видимые столбцы
for (int iRow = 0; iRow < _Control.RowCount; iRow++)
{
if (!_Control.Rows.SharedRow(iRow).Visible)
continue;
for (int j = 0; j < ColIdxs.Length; j++)
yield return new Point(ColIdxs[j], iRow);
}
}
#endregion
#region Выбраны отдельные ячейки, строки или столбцы
private IEnumerator<Point> GetSelectedEnumerator()
{
if (_Control.SelectedRows.Count > 0)
{
int[] ColIdxs = EFPDataGridView.GetSelectedColumnIndices(_Control); // все видимые столбцы
for (int i = 0; i < _Control.SelectedRows.Count; i++)
{
for (int j = 0; j < ColIdxs.Length; j++)
yield return new Point(ColIdxs[j], _Control.SelectedRows[i].Index);
}
}
if (_Control.SelectedColumns.Count > 0)
{
int[] RowIdxs = EFPDataGridView.GetSelectedRowIndices(_Control); // все видимые строки
for (int i = 0; i < RowIdxs.Length; i++)
{
for (int j = 0; j < _Control.SelectedColumns.Count; j++)
yield return new Point(_Control.SelectedColumns[j].Index, RowIdxs[i]);
}
}
if (_Control.SelectedCells.Count > 0)
{
for (int i = 0; i < _Control.SelectedCells.Count; i++)
yield return new Point(_Control.SelectedCells[i].ColumnIndex, _Control.SelectedCells[i].RowIndex);
}
}
#endregion
#region Только текущая ячейка
private IEnumerator<Point> GetCurrentCellEnumerator()
{
if (_Control.CurrentCellAddress.X >= 0 && _Control.CurrentCellAddress.Y >= 0)
yield return _Control.CurrentCellAddress;
}
#endregion
}
/// <summary>
/// Перечислитель по адресам выбранных ячеек (для оператора foreach)
/// </summary>
public SelectedCellAddressEnumerable SelectedCellAddresses { get { return new SelectedCellAddressEnumerable(Control); } }
#endregion
#region Доступ к выбранным ячейкам для источника данных DataView или DataTable
/// <summary>
/// Получение Control.DataSource в виде DataTable или null, если другой источник
/// (не DataTable или DataView).
/// Наличие таблицы-повторителя не учитывается, возвращается таблица, присоединенная к просмотру.
/// Если есть повторитель, то возвращается DataTableRepeater.SlaveTable.
/// </summary>
public DataTable SourceAsDataTable
{
get
{
/*
DataView dv = Control.DataSource as DataView;
if (dv != null)
return dv.Table;
return Control.DataSource as DataTable;
* */
// 24.05.2021
DataView dv = SourceAsDataView;
if (dv == null)
return null;
else
return dv.Table;
}
set
{
((ISupportInitialize)Control).BeginInit();
try
{
Control.DataSource = value;
Control.DataMember = String.Empty;
}
finally
{
((ISupportInitialize)Control).EndInit();
}
}
}
/// <summary>
/// Получение DataGridView.DataSource в виде DataTable
/// Для источника DataTable возвращает DefaultView
/// Возвращает null, если другой источник.
///
/// Наличие таблицы-повторителя не учитывается, возвращается таблица, присоединенная к просмотру.
/// Если есть повторитель, то возвращается DataTableRepeater.SlaveTable.DefaultView
/// </summary>
public DataView SourceAsDataView
{
get
{
/*
DataView dv = Control.DataSource as DataView;
if (dv != null)
return dv;
DataTable table = Control.DataSource as DataTable;
if (table != null)
return table.DefaultView;
return null;
* */
// 24.05.2021
// return GetSourceAsDataView(Control.DataSource, Control.DataMember);
// 04.07.2021
return _SourceAsDataView;
}
set
{
((ISupportInitialize)Control).BeginInit();
try
{
Control.DataSource = value;
Control.DataMember = String.Empty;
}
finally
{
((ISupportInitialize)Control).EndInit();
}
}
}
private DataView _SourceAsDataView;
private static DataView GetSourceAsDataView(object dataSource, string dataMember)
{
object x = ListBindingHelper.GetList(dataSource, dataMember);
DataView dv = x as DataView;
if (dv != null)
return dv;
if (x == null)
return null;
BindingSource bs = x as BindingSource;
if (bs != null)
return GetSourceAsDataView(bs.DataSource, bs.DataMember); // рекурсивный вызов
// Можно было бы проверить у объекта x атрибут [ComplexBindingProperties], но нет гарантии, что это будет DataView с нужным порядком сортировки
return null;
}
/// <summary>
/// Получить строку DataRow таблицы, связанную с заданным объектом строки
/// Строка <paramref name="gridRow"/> должна быть Unshared
/// </summary>
/// <param name="gridRow">Объект строки табличного просмотра</param>
/// <returns>Строка в таблице DataTable</returns>
public static DataRow GetDataRow(DataGridViewRow gridRow)
{
if (gridRow == null)
return null;
// 24.05.2021
// DataBoundItem не может быть ссылкой на DataRow. Всегда только DataRowView
// Может вылазить исключение при попытке обращения к Row.DataBoundItem, если
// оно было связано с DataViewRow для последней строки, когда произошло ее
// удаление
object boundItem;
try
{
boundItem = gridRow.DataBoundItem;
DataRowView drv = boundItem as DataRowView;
if (drv != null)
return drv.Row;
}
catch { }
#if DEBUG
if (gridRow.Index < 0)
throw new ArgumentException("Строка DataGridViewRow является Shared", "gridRow");
#endif
return null;
}
/// <summary>
/// Более предпочтительный способ получения строки DataRow по номеру строки в
/// табличном просмотре. Не делает строку Unshared, т.к. не обращается к
/// объекту DataGridViewRow
/// Статический вариант метода
/// </summary>
/// <param name="control">Табличный просмотр, не обязательно имеющий DocGridHandler</param>
/// <param name="rowIndex">Номер строки</param>
/// <returns>Объект DataRow или null при любой ошибке</returns>
public static DataRow GetDataRow(DataGridView control, int rowIndex)
{
/*
if (control.DataSource is DataView)
{
if (rowIndex < 0 || rowIndex >= ((DataView)(control.DataSource)).Count)
return null;
return ((DataView)(control.DataSource))[rowIndex].Row;
}
if (control.DataSource is DataTable)
{
if (rowIndex < 0 || rowIndex >= ((DataTable)(control.DataSource)).Rows.Count)
return null;
return ((DataTable)(control.DataSource)).DefaultView[rowIndex].Row;
}
return null;
*/
// 24.05.2021
if (rowIndex < 0 || rowIndex >= control.RowCount)
return null;
// Если строка уже является unshared, то есть быстрый доступ добраться до DataRow.
DataGridViewRow gridRow = control.Rows.SharedRow(rowIndex);
if (gridRow.Index >= 0)
return GetDataRow(gridRow);
DataView dv = GetSourceAsDataView(control.DataSource, control.DataMember);
if (dv == null)
{
// Делаем строку Unshared
gridRow = control.Rows[rowIndex];
return GetDataRow(gridRow);
}
else
{
if (rowIndex >= dv.Count)
return null;
else
return dv[rowIndex].Row;
}
}
/// <summary>
/// Более предпочтительный способ получения строки DataRow по номеру строки в
/// табличном просмотре. Не делает строку Unshared, т.к. не обращается к
/// объекту DataGridViewRow
/// Нестатический вариант
/// </summary>
/// <param name="rowIndex">Номер строки</param>
/// <returns>Объект DataRow или null при любой ошибке</returns>
public DataRow GetDataRow(int rowIndex)
{
return EFPDataGridView.GetDataRow(Control, rowIndex);
// 29.09.2017
// Через SharedRow не работает
// Если строка Shared, для нее DataBoundItem равно null
//if (RowIndex < 0 || RowIndex >= Control.RowCount)
// return null;
//else
// return GetDataRow(Control.Rows.SharedRow(RowIndex));
}
/// <summary>
/// Получить массив строк DataRow по индексам строк.
/// Если какой-либо индекс не относится к DataRow, элемент массива содержит null.
/// </summary>
/// <param name="rowIndices">Номера строк в просмотре DataGridView</param>
/// <returns>Массив объектов DataRow</returns>
public DataRow[] GetDataRows(int[] rowIndices)
{
DataView dv = null;
bool dvDefined = false;
DataRow[] Rows = new DataRow[rowIndices.Length];
for (int i = 0; i < Rows.Length; i++)
{
if (rowIndices[i] >= 0 && rowIndices[i] < Control.RowCount)
{
// Если строка уже является unshared, то есть быстрый доступ добраться до DataRow.
// Обычно, этот вариант и будет работать, так как, скорее всего, опрашиваются выбранные строки
DataGridViewRow gridRow = Control.Rows.SharedRow(rowIndices[i]);
if (gridRow.Index >= 0)
Rows[i] = GetDataRow(gridRow);
else
{
if (!dvDefined)
{
dvDefined = true;
dv = SourceAsDataView;
}
if (rowIndices[i] < dv.Count)
Rows[i] = dv[rowIndices[i]].Row;
}
}
}
return Rows;
}
/// <summary>
/// Получить или установить выбранные строки в просмотре.
/// Расширяет реализацию свойства SelectedRows, используя вместо объектов
/// DataGridViewRow строки таблицы данных DataRow.
/// Если просмотр не присоединен к таблице данных, свойство возвращает массив, содержащий значения null.
///
/// Если используется таблица-повторитель, то возвращаются и должны устанавливаться строки таблицы, присоединенной к просмотру,
/// то есть DataTableRepeater.SlaveTable.
/// </summary>
public DataRow[] SelectedDataRows
{
get
{
DataRow[] res;
if (Control.AreAllCellsSelected(true)) // надо бы AreAllRowsSelected
{
// 24.05.2021
// Оптимизированный метод без доступа к DataGridViewRow
DataView dv = SourceAsDataView;
if (dv == null)
return new DataRow[Control.RowCount];
else
{
res = new DataRow[dv.Count];
for (int i = 0; i < res.Length; i++)
res[i] = dv[i].Row;
}
}
else
{
DataGridViewRow[] gridRows = SelectedGridRows;
res = new DataRow[gridRows.Length];
for (int i = 0; i < res.Length; i++)
res[i] = GetDataRow(gridRows[i]);
}
return res;
}
set
{
if (value.Length == 0)
return;
// Тут несколько гадко
// Поэтому сначала проверяем, есть ли какие-нибудь изменения
DataRow[] OrgRows = SelectedDataRows;
if (OrgRows.Length == value.Length)
{
bool Differ = false;
for (int i = 0; i < value.Length; i++)
{
if (value[i] != OrgRows[i])
{
Differ = true;
break;
}
}
if (!Differ)
return; // строки не изменились
}
DataView dv = SourceAsDataView;
if (dv == null)
throw new InvalidDataSourceException("Просмотр не связан с DataView");
if (dv.Count != Control.RowCount)
return; // 09.02.2021. Просмотр может быть еще не выведен на экран и Control.RowCount==0.
if (value.Length == 1)
{
// 04.07.2021 Оптимизация
if (value[0] == null)
return;
if (Object.ReferenceEquals(CurrentDataRow, value[0]))
{
SelectedGridRows = new DataGridViewRow[1] { CurrentGridRow };
return;
}
int p = DataTools.FindDataRowViewIndex(dv, value[0]);
if (p >= 0) // исправлено 16.08.2021
SelectedRowIndices = new int[1] { p };
return;
}
DataGridViewRow[] Rows = new DataGridViewRow[value.Length];
// Производительность будет ужасной, если выбрано много строк в большой таблице
int SelCnt = 0; // Вдруг найдем все строки до того, как переберем весь набор данных ?
for (int j = 0; j < dv.Count; j++)
{
DataRow ThisRow = GetDataRow(j);
for (int k = 0; k < value.Length; k++)
{
if (value[k] == ThisRow)
{
Rows[k] = Control.Rows[j];
SelCnt++;
break;
}
}
if (SelCnt == value.Length)
break; // уже все нашли
}
SelectedGridRows = Rows;
}
}
/// <summary>
/// Расширение свойства CurrentRow (чтение и установка текущей строки).
/// В качестве значения используется строка таблицы данных (объект DataRow)
/// Просмотр должен быть присоединен к DataSource типа DataView.
///
/// Если используется таблица-повторитель, то возвращается и должна устанавливаться строка таблицы, присоединенной к просмотру,
/// то есть DataTableRepeater.SlaveTable.
/// </summary>
public DataRow CurrentDataRow
{
get
{
return GetDataRow(Control.CurrentRow); // 24.05.2021
}
set
{
if (value == null)
return;
DataView dv = SourceAsDataView;
if (dv == null)
throw new InvalidDataSourceException("Свойство DataGridView.DataSource не является DataView или DataTable");
// 04.07.2021
// Оптимизация
if (Object.ReferenceEquals(value, GetDataRow(Control.CurrentRow)))
return;
int p = DataTools.FindDataRowViewIndex(dv, value);
if (p >= 0)
CurrentRowIndex = p;
}
}
#if XXX
/// <summary>
/// Выделяет строку в просмотре, соответствующую заданной строке DataRow.
/// Используйте установку свойства CurrentDataRow
/// </summary>
/// <param name="row"></param>
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[Obsolete("Используйте установку свойства CurrentDataRow", false)]
public void SelectDataRow(DataRow row)
{
CurrentDataRow = row;
}
#endif
/// <summary>
/// Расширение свойств SelectedRows / SelectedDataRows
/// В качестве текущих позиций запоминаются значения ключевых полей в DataTable
/// Первый индекс двумерного массива соответствует количеству строк.
/// Второй индекс соответствует количеству полей в DataTable.PrimaryKey
/// (обычно равно 1)
/// Свойство возвращает null, если таблица не присоединена к просмотру (напрямую или через DataView)
/// или не имеет первичного ключа
/// </summary>
public object[,] SelectedDataRowKeys
{
get
{
DataRow[] Rows = SelectedDataRows;
DataTable Table = SourceAsDataTable;
if (Table == null)
return null;
if (Table.PrimaryKey == null || Table.PrimaryKey.Length == 0)
return null;
return DataTools.GetPrimaryKeyValues(Table, Rows);
}
set
{
if (value == null)
return;
DataTable Table = SourceAsDataTable;
if (Table == null)
throw new InvalidOperationException("DataGridView.DataSource не является DataTable");
DataRow[] Rows = DataTools.GetPrimaryKeyRows(Table, value);
SelectedDataRows = Rows;
}
}
/// <summary>
/// Расширение свойств CurrentRow / CurrentDataRow для получения / установки
/// текущей строки с помощью значений ключевых полей в DataTable
/// </summary>
public object[] CurrentDataRowKeys
{
get
{
DataRow Row = CurrentDataRow;
if (Row == null)
return null;
return DataTools.GetPrimaryKeyValues(Row);
}
set
{
DataTable Table = SourceAsDataTable;
if (Table == null)
throw new InvalidOperationException("DataGridView.DataSource не является DataTable");
if (value == null)
return;
DataRow Row = Table.Rows.Find(value);
if (Row == null)
return;
CurrentDataRow = Row;
}
}
/// <summary>
/// Расширение свойств SelectedRows / SelectedDataRows
/// В качестве текущих позиций запоминаются значения полей, заданных в DataView.ViewOrder
/// Первый индекс двумерного массива соответствует количеству строк.
/// Второй индекс соответствует количеству полей сортировки в DataView
/// (обычно равно 1)
/// Свойство возвращает null, если просмотру не соединен с DataView
/// или DataView не имеет полей сортировки
/// </summary>
public object[,] SelectedDataViewSortKeys
{
get
{
DataView dv = SourceAsDataView;
if (dv == null)
return null;
if (String.IsNullOrEmpty(dv.Sort))
return null;
string[] flds = DataTools.GetDataViewSortColumnNames(dv.Sort);
DataRow[] Rows = SelectedDataRows;
object[,] Values = new object[Rows.Length, flds.Length];
for (int i = 0; i < Rows.Length; i++)
{
for (int j = 0; j < flds.Length; j++)
Values[i, j] = Rows[i][flds[j]];
}
return Values;
}
set
{
if (value == null)
return;
DataView dv = SourceAsDataView;
if (dv == null)
throw new InvalidOperationException("К просмотру не присоединен объект DataView");
if (String.IsNullOrEmpty(dv.Sort))
throw new InvalidOperationException("Присоединенный к просмотру объект DataView не имеет полей сортировки");
int nRows = value.GetLength(0);
if (nRows == 0)
return;
object[] Keys = new object[value.GetLength(1)];
List<int> rowIndices = new List<int>();
for (int i = 0; i < nRows; i++)
{
for (int j = 0; j < Keys.Length; j++)
Keys[j] = value[i, j];
int idx = dv.Find(Keys);
if (idx > 0)
rowIndices.Add(idx);
}
SelectedRowIndices = rowIndices.ToArray();
}
}
/// <summary>
/// Расширение свойств CurrentRow / CurrentDataRow для получения / установки
/// текущей строки с помощью значений полей сортировки в DataView
/// </summary>
public object[] CurrentDataViewSortKeys
{
get
{
DataView dv = SourceAsDataView;
if (dv == null)
return null;
if (String.IsNullOrEmpty(dv.Sort))
return null;
string[] flds = DataTools.GetDataViewSortColumnNames(dv.Sort);
DataRow Row = CurrentDataRow;
object[] Values = new object[flds.Length];
if (Row != null)
{
for (int j = 0; j < flds.Length; j++)
Values[j] = Row[flds[j]];
}
return Values;
}
set
{
if (value == null)
return;
DataView dv = SourceAsDataView;
if (dv == null)
throw new InvalidOperationException("К просмотру не присоединен объект DataView");
if (String.IsNullOrEmpty(dv.Sort))
throw new InvalidOperationException("Присоединенный к просмотру объект DataView не имеет полей сортировки");
int idx = dv.Find(value);
if (idx > 0)
CurrentRowIndex = idx;
}
}
#endregion
#region Повторитель таблицы DataTableRepeater
/// <summary>
/// Повторитель таблицы.
/// При установке свойства устанавливается DataGridView.DataSource=DataTableRepeater.SlaveTable.
/// Предполагается, что повторитель относится персонально к этому табличному просмотру.
/// Когда управляющий элемент разрушается, вызывается DataTableRepeater.Dispose().
/// При повторной установке значения предыдущий повторитель также удаляется.
/// </summary>
public DataTableRepeater TableRepeater
{
get { return _TableRepeater; }
set
{
if (object.ReferenceEquals(value, _TableRepeater))
return;
Control.DataSource = null;
Control.DataMember = null;
if (_TableRepeater != null)
_TableRepeater.Dispose();
_TableRepeater = value;
if (_TableRepeater != null)
Control.DataSource = _TableRepeater.SlaveTable.DefaultView;
}
}
private DataTableRepeater _TableRepeater;
/// <summary>
/// Вызывает DataTableRepeater.Dispose(), если свойство TableRepeater было установлено.
/// </summary>
protected override void OnDisposed()
{
if (_TableRepeater != null)
{
_TableRepeater.Dispose();
_TableRepeater = null;
}
base.OnDisposed();
}
/// <summary>
/// Возвращает строку в таблице-повторителе DataTableRepeater.SlaveTable, которая соответствует строке в исходной таблице DataTableRepeater.MasterTable.
/// Если повторитель TableRepeater не установлен, возврашает исходные данные без изменений.
/// </summary>
/// <param name="masterRow">Строка таблицы MasterTable</param>
/// <returns>Строка таблицы SlaveTable</returns>
public DataRow GetSlaveRow(DataRow masterRow)
{
if (_TableRepeater == null)
return masterRow;
else
return _TableRepeater.GetSlaveRow(masterRow);
}
/// <summary>
/// Возвращает строки в таблице-повторителе DataTableRepeater.SlaveTable, которые соответствуют строкам в исходной таблице DataTableRepeater.MasterTable
/// Если повторитель TableRepeater не установлен, возврашает исходные данные без изменений.
/// </summary>
/// <param name="masterRows">Массив строк таблицы MasterTable</param>
/// <returns>Строки таблицы SlaveTable</returns>
public DataRow[] GetSlaveRows(DataRow[] masterRows)
{
if (_TableRepeater == null)
return masterRows;
else
return _TableRepeater.GetSlaveRows(masterRows);
}
/// <summary>
/// Возвращает строку в основной таблице DataTableRepeater.MasterTable, которая соответствует строке в таблице-повторителе DataTableRepeater.SlaveTable.
/// Используется для реализации редактирования, т.к. изменения должны вноситься в ведущую
/// таблицу, а не ту, которая отображается в просмотре.
/// Если повторитель TableRepeater не установлен, возврашает исходные данные без изменений.
/// </summary>
/// <param name="slaveRow">Строка таблицы SlaveTable</param>
/// <returns>Строка таблицы MasterTable</returns>
public DataRow GetMasterRow(DataRow slaveRow)
{
if (_TableRepeater == null)
return slaveRow;
else
return _TableRepeater.GetMasterRow(slaveRow);
}
/// <summary>
/// Возвращает строки в основной таблице DataTableRepeater.MasterTable, которые соответствуют строкам в таблице-повторителе DataTableRepeater.SlaveTable.
/// Используется для реализации редактирования, т.к. изменения должны вноситься в ведущую
/// таблицу, а не ту, которая отображается в просмотре.
/// Если повторитель TableRepeater не установлен, возврашает исходные данные без изменений.
/// </summary>
/// <param name="slaveRows">Строки таблицы SlaveTable</param>
/// <returns>Строки таблицы MasterTable</returns>
public DataRow[] GetMasterRows(DataRow[] slaveRows)
{
if (_TableRepeater == null)
return slaveRows;
else
return _TableRepeater.GetMasterRows(slaveRows);
}
/// <summary>
/// Если есть таблица-повторитель, то возвращается мастер-таблица DataTableRepeater.MasterTable.
/// Иначе возвращается SourceAsDataTable.
/// </summary>
public DataTable MasterDataTable
{
get
{
if (_TableRepeater == null)
return SourceAsDataTable;
else
return _TableRepeater.MasterTable;
}
}
/// <summary>
/// Если есть таблица-повторитель, то возвращается DataView для мастер-таблицы DataTableRepeater.MasterTable.DefaultView.
/// Иначе возвращается SourceAsDataView.
/// </summary>
public DataView MasterDataView
{
get
{
if (TableRepeater == null)
return SourceAsDataView;
else
return _TableRepeater.MasterTable.DefaultView;
}
}
#endregion
#region Видимые строки
/// <summary>
/// Возвращает массив объектов DataRow, связанных со строками, видимыми в просмотре
/// </summary>
public DataRow[] DisplayedDataRows
{
get
{
int FirstRow = Control.FirstDisplayedScrollingRowIndex;
int n = Control.DisplayedRowCount(true);
List<DataRow> Rows = new List<DataRow>(n);
for (int i = 0; i < n; i++)
{
DataRow Row = GetDataRow(FirstRow + i);
if (Row != null)
Rows.Add(Row);
}
return Rows.ToArray();
}
}
#endregion
#region Сохранение / восстановление выбранных строк
/// <summary>
/// Режим сохранения выбранных строк свойствами SelectedRowsObject и
/// CurrentRowObject
/// По умолчанию для EFPDataGridView - значение None.
/// Может быть переопределено в производных классах
/// </summary>
public EFPDataGridViewSelectedRowsMode SelectedRowsMode
{
get { return _SelectedRowsMode; }
set { _SelectedRowsMode = value; }
}
private EFPDataGridViewSelectedRowsMode _SelectedRowsMode;
/// <summary>
/// Сохранение и восстановление выбранных строк просмотра в виде одного объекта,
/// в зависимости от свойства SelectedRowsMode
/// </summary>
public virtual object SelectedRowsObject
{
get
{
try
{
switch (SelectedRowsMode)
{
case EFPDataGridViewSelectedRowsMode.RowIndex:
return SelectedRowIndices;
case EFPDataGridViewSelectedRowsMode.DataRow:
return GetMasterRows(SelectedDataRows);
case EFPDataGridViewSelectedRowsMode.PrimaryKey:
return SelectedDataRowKeys;
case EFPDataGridViewSelectedRowsMode.DataViewSort:
return SelectedDataViewSortKeys;
}
}
catch
{
}
return null;
}
set
{
if (value == null)
return;
switch (SelectedRowsMode)
{
case EFPDataGridViewSelectedRowsMode.RowIndex:
SelectedRowIndices = (int[])value;
break;
case EFPDataGridViewSelectedRowsMode.DataRow:
SelectedDataRows = GetSlaveRows((DataRow[])value);
break;
case EFPDataGridViewSelectedRowsMode.PrimaryKey:
SelectedDataRowKeys = (object[,])value;
break;
case EFPDataGridViewSelectedRowsMode.DataViewSort:
SelectedDataViewSortKeys = (object[,])value;
break;
}
}
}
/// <summary>
/// Сохранение и восстановление текущей (одной) строки просмотра.
/// Тип свойства зависит от режима SelectedRowsMode.
/// </summary>
public virtual object CurrentRowObject
{
get
{
try
{
switch (SelectedRowsMode)
{
case EFPDataGridViewSelectedRowsMode.RowIndex:
return Control.CurrentCellAddress.Y;
case EFPDataGridViewSelectedRowsMode.DataRow:
return GetMasterRow(CurrentDataRow); // 04.07.2021
case EFPDataGridViewSelectedRowsMode.PrimaryKey:
return CurrentDataRowKeys;
case EFPDataGridViewSelectedRowsMode.DataViewSort:
return CurrentDataViewSortKeys;
}
}
catch
{
}
return null;
}
set
{
if (value == null)
return;
switch (SelectedRowsMode)
{
case EFPDataGridViewSelectedRowsMode.RowIndex:
int RowIndex = (int)value;
if (RowIndex >= 0 && RowIndex < Control.Rows.Count)
CurrentGridRow = Control.Rows[RowIndex];
break;
case EFPDataGridViewSelectedRowsMode.DataRow:
CurrentDataRow = GetSlaveRow((DataRow)value); // 04.07.2021
break;
case EFPDataGridViewSelectedRowsMode.PrimaryKey:
CurrentDataRowKeys = (object[])value;
break;
case EFPDataGridViewSelectedRowsMode.DataViewSort:
CurrentDataViewSortKeys = (object[])value;
break;
}
}
}
/// <summary>
/// Сохранение и восстановление текущих строк и столбца табличного просмотра.
/// Режим сохранения строк определеятся свойство SelectedRowsMode
/// Значение включает в себя: признак AreAllCellsSelected, список выделенных
/// строк SelectedRowsObject, текущую строку CurrentRowObject и индекс
/// столбца с текущей ячейкой CurrentColumnIndex.
/// При установке значения свойства перехватываются все исключения.
/// </summary>
public EFPDataGridViewSelection Selection
{
get
{
EFPDataGridViewSelection res = new EFPDataGridViewSelection();
if (Control.RowCount > 0) // 11.08.2015. Иначе при отсутствии строк считается, что выделены все строки
{
res.SelectAll = Control.AreAllCellsSelected(false);
if (!res.SelectAll)
res.SelectedRows = SelectedRowsObject;
res.CurrentRow = CurrentRowObject;
}
res.CurrentColumnIndex = CurrentColumnIndex;
res.DataSourceExists = Control.DataSource != null;
return res;
}
set
{
if (value == null)
return;
try
{
CurrentColumnIndex = value.CurrentColumnIndex;
bool DataSouceExists = (Control.DataSource != null);
if (DataSouceExists == value.DataSourceExists)
{
CurrentRowObject = value.CurrentRow;
if (value.SelectAll)
Control.SelectAll();
else
SelectedRowsObject = value.SelectedRows;
}
}
catch // 26.09.2018
{
}
}
}
#endregion
#region Текущий столбец
/// <summary>
/// Номер текущего столбца. Если выбрано несколько столбцов (например, строка целиком),
/// то (-1)
/// </summary>
public int CurrentColumnIndex
{
get
{
if (_CurrentColumnIndex < 0)
return DefaultColumnIndex; // 16.05.2018
//{
// for (int i = 0; i < Control.Columns.Count; i++)
// {
// if (Control.Columns[i].Visible)
// return i;
// }
// return -1;
//}
else
return _CurrentColumnIndex;
}
set
{
if (value < 0 || value >= Control.ColumnCount)
return;
if (!Control.Columns[value].Visible)
return;
int RowIndex = Control.CurrentCellAddress.Y;
if (Control.Visible && RowIndex >= 0 && RowIndex < Control.Rows.Count)
{
try
{
Control.CurrentCell = Control.Rows[RowIndex].Cells[value];
}
catch
{
}
}
_CurrentColumnIndex = value;
}
}
/// <summary>
/// Сохраняем установленный ColumnIndex, если потом произойдет пересоздание просмотра
/// </summary>
private int _CurrentColumnIndex;
/// <summary>
/// Текущий столбец. Если выбрано несколько столбцов (например, строка целиком),
/// то null
/// </summary>
public EFPDataGridViewColumn CurrentColumn
{
get
{
if (CurrentColumnIndex < 0 || CurrentColumnIndex >= Control.ColumnCount)
return null;
else
return Columns[CurrentColumnIndex];
}
set
{
CurrentColumnIndex = value.GridColumn.Index;
}
}
/// <summary>
/// Имя текущего столбца. Если выбрано несколько столбцов (например, строка целиком),
/// то пустая строка ("")
/// </summary>
public string CurrentColumnName
{
get
{
if (CurrentColumnIndex < 0 || CurrentColumnIndex >= Control.ColumnCount)
return String.Empty;
else
return Control.Columns[CurrentColumnIndex].Name;
}
set
{
EFPDataGridViewColumn Column = Columns[value];
if (Column != null)
CurrentColumnIndex = Column.GridColumn.Index;
}
}
#endregion
#region Столбец по умолчанию
/// <summary>
/// Возвращает индекс столбца, который следует активировать по умолчанию.
/// При показе просмотра, если свойство CurrentColumnIndex не установлено в явном виде,
/// выбирается этот столбец.
/// Предпочтительно возвращает первый столбец с инкрементным поиском.
/// Иначе старается вернуть первый столбец, кроме значка.
/// Скрытые столбцы пропускаются.
/// </summary>
public int DefaultColumnIndex
{
get
{
DataGridViewColumn[] a = VisibleGridColumns;
int FirstIdx = -1;
for (int i = 0; i < a.Length; i++)
{
if (a[i] is DataGridViewImageColumn)
continue;
if (FirstIdx < 0)
FirstIdx = a[i].Index;
EFPDataGridViewColumn Col = Columns[a[i]]; // предпочтительный вариант индексированного свойства
if (Col.CanIncSearch)
return a[i].Index;
}
if (FirstIdx >= 0)
return FirstIdx;
// Ничего не нашли
if (a.Length > 0)
return a[0].Index;
else
return -1;
}
}
#endregion
#region Видимые столбцы
/// <summary>
/// Получить массив видимых столбцов в просмотре в порядке вывода на экран
/// Объекты EFPDataGridViewColumn
/// </summary>
public EFPDataGridViewColumn[] VisibleColumns
{
get
{
DataGridViewColumn[] cols = VisibleGridColumns;
EFPDataGridViewColumn[] a = new EFPDataGridViewColumn[cols.Length];
for (int i = 0; i < cols.Length; i++)
a[i] = Columns[cols[i]];
return a;
}
}
#if XXX
/// <summary>
/// Получить столбцы с заданными условиями в виде массива
/// </summary>
/// <param name="states"></param>
/// <returns></returns>
[Obsolete("Не работает в MONO", false)]
public DataGridViewColumn[] GetGridColumns(DataGridViewElementStates states)
{
List<DataGridViewColumn> Columns = new List<DataGridViewColumn>();
DataGridViewColumn Col = Control.Columns.GetFirstColumn(states);
while (Col != null)
{
Columns.Add(Col);
Col = Control.Columns.GetNextColumn(Col, states, DataGridViewElementStates.None);
}
return Columns.ToArray();
}
#endif
/// <summary>
/// Получить массив видимых столбцов в просмотре в порядке вывода на экран
/// Объекты столбцов табличного просмотра
/// </summary>
public DataGridViewColumn[] VisibleGridColumns
{
get
{
return WinFormsTools.GetOrderedVisibleColumns(Control);
//return GetGridColumns(DataGridViewElementStates.Visible);
}
}
/// <summary>
/// Количество "замороженных" столбцов в просмотре
/// (по умолчанию 0 - нет замороженных столбцов)
/// </summary>
[DefaultValue(0)]
public int FrozenColumns
{
get
{
return Control.Columns.GetColumnCount(DataGridViewElementStates.Frozen);
}
set
{
// ???
if (value > 0)
Control.Columns[value - 1].Frozen = true;
if (Control.Columns.Count > value)
Control.Columns[value].Frozen = false;
}
}
#endregion
#region Видимые строки
/// <summary>
/// Получить строки с заданными условиями в виде массива
/// </summary>
/// <param name="states"></param>
/// <returns></returns>
public DataGridViewRow[] GetGridRows(DataGridViewElementStates states)
{
List<DataGridViewRow> Rows = new List<DataGridViewRow>();
int RowIndex = Control.Rows.GetFirstRow(states);
while (RowIndex >= 0)
{
Rows.Add(Control.Rows[RowIndex]);
RowIndex = Control.Rows.GetNextRow(RowIndex, states, DataGridViewElementStates.None);
}
return Rows.ToArray();
}
/// <summary>
/// Получить массив видимых строк в просмотре в порядке вывода на экран
/// Объекты видимых строк табличного просмотра
/// </summary>
public DataGridViewRow[] VisibleGridRows
{
get
{
return GetGridRows(DataGridViewElementStates.Visible);
}
}
/// <summary>
/// Возвращает высоту в пикселах, которую бы хотел иметь табличный просмотр
/// для размещения всех строк
/// Возвращаемое значение не превышает высоту экрана
/// </summary>
public int WantedHeight
{
get
{
// Максимальная высота, которую можно вернуть
int hMax = Screen.FromControl(Control).Bounds.Height;
int h = 0;
// рамка
switch (Control.BorderStyle)
{
case BorderStyle.FixedSingle:
h += SystemInformation.BorderSize.Height * 2;
break;
case BorderStyle.Fixed3D:
h += SystemInformation.Border3DSize.Height * 2;
break;
}
// полоса прокрутки
if (Control.ScrollBars == ScrollBars.Horizontal || Control.ScrollBars == ScrollBars.Both)
h += SystemInformation.HorizontalScrollBarHeight;
// заголовки столбцов
if (Control.ColumnHeadersVisible)
h += Control.ColumnHeadersHeight;
// строки
for (int i = 0; i < Control.Rows.Count; i++)
{
if (Control.Rows[i].Visible)
{
h += Control.Rows[i].Height;
if (h >= hMax)
break;
}
}
return Math.Min(h, hMax);
}
}
#endregion
#region InvalidateRows()
/// <summary>
/// Обновить строки табличного просмотра.
/// Выполняет только вызов Control.InvalidateRow().
/// Для обновления строк с загрузкой данных используйте UpdateRows()
/// </summary>
/// <param name="rowIndices">Индексы строк в просмотре или null, если должны быть обновлены все строки</param>
public void InvalidateRows(int[] rowIndices)
{
if (rowIndices == null)
Control.Invalidate();
else
{
for (int i = 0; i < rowIndices.Length; i++)
{
if (rowIndices[i] >= 0 && rowIndices[i] < Control.RowCount) // проверка добавлена 16.04.2018
Control.InvalidateRow(rowIndices[i]);
}
}
}
#if XXX
/// <summary>
/// Обновить все строки табличного просмотра.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
[Obsolete("Используйте InvalidateAllRows()", false)]
public void InvalidateRows()
{
InvalidateAllRows();
}
#endif
/// <summary>
/// Обновить все строки табличного просмотра.
/// </summary>
public void InvalidateAllRows()
{
InvalidateRows(null);
}
/// <summary>
/// Обновить в просмотре все выбранные строки SelectedRows, например, после
/// редактирования, если имеются вычисляемые столбцы
/// </summary>
public void InvalidateSelectedRows()
{
if (Control.AreAllCellsSelected(false))
InvalidateRows(null);
else
InvalidateRows(SelectedRowIndices);
}
/// <summary>
/// Пометить на обновление строки табличного просмотра, связанные с заданными строками таблицы данных
/// </summary>
/// <param name="rows">Массив строк связанной таблицы данных</param>
public void InvalidateDataRows(DataRow[] rows)
{
if (rows == null)
return;
if (rows.Length == 0)
return;
if (rows.Length == 1)
{
InvalidateDataRow(rows[0]);
return;
}
// Выгодно сначала найти все DataRow, которые есть на экране (их немного),
// а затем просматривать требуемый список DataRow (может быть длинный)
int FirstRow = Control.FirstDisplayedScrollingRowIndex;
int n = Control.DisplayedRowCount(true);
Dictionary<DataRow, int> RowIdxs = new Dictionary<DataRow, int>(n);
for (int i = 0; i < n; i++)
{
DataRow R = GetDataRow(FirstRow + i);
if (R != null)
RowIdxs.Add(R, FirstRow + i);
}
for (int i = 0; i < rows.Length; i++)
{
int RowIdx;
if (RowIdxs.TryGetValue(rows[i], out RowIdx))
InvalidateRows(new int[1] { RowIdx });
}
}
/// <summary>
/// Пометить на обновление строку табличного просмотра, связанную с заданной строкой таблицы данных
/// </summary>
/// <param name="row">Строка связанной таблицы данных</param>
public void InvalidateDataRow(DataRow row)
{
if (row == null)
return;
int FirstRow = Control.FirstDisplayedScrollingRowIndex;
int n = Control.DisplayedRowCount(true);
for (int i = 0; i < n; i++)
{
if (GetDataRow(FirstRow + i) == row)
{
InvalidateRows(new int[1] { FirstRow + i });
break;
}
}
}
#endregion
#region UpdateRows()
/// <summary>
/// Обновить строки табличного просмотра, загрузив исходные данные.
/// Производный класс должен обновить данные в источнике данных просмотра.
/// Непереопределенная реализация в EFPDataGridView() просто вызывает InvalidateRows()
/// </summary>
/// <param name="rowIndices">Индексы строк в просмотре или null, если должны быть обновлены все строки</param>
public virtual void UpdateRows(int[] rowIndices)
{
InvalidateRows(rowIndices);
}
/// <summary>
/// Обновить все строки табличного просмотра.
/// </summary>
public void UpdateRows()
{
UpdateRows(null);
}
/// <summary>
/// Обновить в просмотре все выбранные строки SelectedRows, например, после
/// редактирования, если имеются вычисляемые столбцы
/// </summary>
public void UpdateSelectedRows()
{
if (Control.AreAllCellsSelected(false))
UpdateRows(null);
else
UpdateRows(SelectedRowIndices);
}
/// <summary>
/// Обновить строки табличного просмотра, связанные с заданными строками таблицы данных
/// </summary>
/// <param name="rows">Массив строк связанной таблицы данных</param>
public void UpdateDataRows(DataRow[] rows)
{
if (rows == null)
return;
if (rows.Length == 0)
return;
if (rows.Length == 1)
{
UpdateDataRow(rows[0]); // более быстрый метод
return;
}
DataView dv = SourceAsDataView;
if (dv == null)
throw new InvalidOperationException("Табличный просмотр не связан с набором данных");
Dictionary<DataRow, int> allRowIndices = new Dictionary<DataRow, int>(dv.Count);
for (int i = 0; i < dv.Count; i++)
allRowIndices.Add(dv[i].Row, i);
List<int> UsedIndices = new List<int>(rows.Length); // некоторых строк может не быть
for (int i = 0; i < rows.Length; i++)
{
int idx;
if (allRowIndices.TryGetValue(rows[i], out idx))
UsedIndices.Add(idx);
}
UpdateRows(UsedIndices.ToArray());
}
/// <summary>
/// Обновить строку табличного просмотра, связанную с заданной строкой таблицы данных
/// </summary>
/// <param name="row">Строка связанной таблицы данных</param>
public void UpdateDataRow(DataRow row)
{
if (row == null)
return;
DataView dv = SourceAsDataView;
if (dv == null)
throw new InvalidOperationException("Табличный просмотр не связан с набором данных");
// Нет оптимального метода поиска
for (int i = 0; i < dv.Count; i++)
{
if (dv[i].Row == row)
{
UpdateRows(new int[1] { i });
return;
}
}
}
#endregion
#region Порядок строк
#region Предопределенная сортировка
/// <summary>
/// Описатели команд меню "Порядок строк" - массив объектов, задающих режимы
/// предопределенной сортировки.
/// </summary>
public EFPDataViewOrders Orders
{
get
{
if (_Orders == null)
_Orders = CreateOrders();
return _Orders;
}
}
private EFPDataViewOrders _Orders;
/// <summary>
/// Создает объект EFPDataGridViewOrders.
/// </summary>
/// <returns>Новый объект</returns>
protected virtual EFPDataViewOrders CreateOrders()
{
return new EFPDataViewOrders();
}
/// <summary>
/// Количество элементов в массиве Orders
/// </summary>
public int OrderCount
{
get
{
if (_Orders == null)
return 0;
else
return _Orders.Count;
}
}
/// <summary>
/// Текущий порядок предопределенной сортировки (индекс в массиве Orders).
/// Если используется произвольная сортировка сортировка не установлена, свойство возращает (-1).
/// Для инициализации произвольной сортировки устанавливайте свойство CustomOrderActive.
/// </summary>
public int CurrentOrderIndex
{
get
{
if ((!_CustomOrderActive) && _CurrentOrder != null)
return Orders.IndexOf(_CurrentOrder);
else
return -1;
}
set
{
if (value < 0 || value >= OrderCount)
throw new ArgumentOutOfRangeException("value",
"Индекс сортировки должен быть в диапазоне от 0 до " + (OrderCount - 1).ToString());
_CurrentOrder = Orders[value];
_CustomOrderActive = false;
_CustomOrderAutoActivated = false;
InternalSetCurrentOrder();
}
}
private void InternalSetCurrentOrder()
{
if (ProviderState != EFPControlProviderState.Attached)
return;
EFPDataGridViewSelection OldSel = Selection;
CommandItems.InitCurentOrder();
if (WinFormsTools.AreControlAndFormVisible(Control))
{
if (OrderChangesToRefresh)
PerformRefresh();
else
{
if (AutoSort)
{
if (Control.DataSource != null)
PerformAutoSort();
}
else
{
if (OrderChanged == null)
throw new InvalidOperationException("OrderChangesToRefresh=false, AutoSort=false и событие OrderChanged не имеет обработчика");
OnOrderChanged(EventArgs.Empty);
}
}
}
Selection = OldSel;
OnCurrentOrderChanged(EventArgs.Empty);
if (ProviderState == EFPControlProviderState.Attached)
CommandItems.InitOrderItems();
InitColumnHeaderTriangles();
}
#endregion
#region Произвольная сортировка
/// <summary>
/// Разрешение использовать произвольную сортировку.
/// По умолчанию - false - запрещено (если не переопределено в конструкторе производного класса).
/// Свойство можно устанавливать только до вызова события Created.
/// </summary>
public bool CustomOrderAllowed
{
get { return _CustomOrderAllowed; }
set
{
CheckHasNotBeenCreated();
if (value == _CustomOrderAllowed)
return;
if ((!value) && CustomOrderActive)
throw new InvalidOperationException("Свойство CustomOrderActive уже установлено");
_CustomOrderAllowed = value;
}
}
private bool _CustomOrderAllowed;
/// <summary>
/// True, если в текущий момент используется произвольная сортировка.
/// Для установки в true, требуется сначала установить CustomOrderAllowed=true.
///
/// При переключении с предопределнной сортировки на произвольную проверяется с помощью IsSelectableCustomOrder(), что для текущей сортировки CurrentOrder в
/// просмотре имеются все столбцы, с помощью которых такую сортировку можно воспроизвести. Если столбцов не хватает,
/// устанавливается произвольная сортировка по умолчанию. Если же и DefaultCustomOrder возвращает null, то переключение
/// не выполняется и CustomOrderActive остается равным false.
///
/// При переключении с произвольной сортировки на предопределенную выполняется поиск в списке Orders порядка,
/// соответствующему CurrentOrder. Если найден, то он устанавливается. Иначе выбирается первый элемент в списке Orders.
/// Если список Orders пустой, устанавливается CurrentOrder=null.
/// </summary>
public bool CustomOrderActive
{
get { return _CustomOrderActive; }
set
{
if (value == _CustomOrderActive)
return;
if (!_CustomOrderAllowed)
throw new InvalidOperationException("Произвольная сортировка запрещена для этого просмотра");
_CustomOrderActive = value;
_CustomOrderAutoActivated = false;
if (value)
{
// Если можно, сохраняем тот порядок, который был
if (_CurrentOrder == null || (!IsSelectableCustomOrder(_CurrentOrder)))
{
_CurrentOrder = DefaultCustomOrder;
if (_CurrentOrder == null) // на нашли сортировки по умолчанию
_CustomOrderActive = false;
}
}
else
{
bool found = false;
if (CurrentOrder != null)
{
for (int i = 0; i < Orders.Count; i++)
{
if (Orders[i].Sort == CurrentOrder.Sort)
{
CurrentOrderIndex = i;
found = true;
break;
}
}
}
if (!found)
{
if (OrderCount > 0)
CurrentOrderIndex = 0;
else
CurrentOrder = null;
}
}
InitColumnSortMode();
InternalSetCurrentOrder();
}
}
private bool _CustomOrderActive;
/// <summary>
/// Возвращает порядок выборочной сортировки по умолчанию.
/// Находится первый видимый столбец, для которого разрешена пользовательская сортировка.
/// Возвращается новый EFPDataViewOrder для одного столбца с сортировкой по возрастанию.
/// Если в просмотре нет ни одного столбца с разрешенной произвольной сортировкой, возвращается null.
///
/// Никаких изменений в просмотре не происходит
/// </summary>
/// <returns>EFPDataViewOrder или null</returns>
public EFPDataViewOrder DefaultCustomOrder
{
get
{
EFPDataGridViewColumn[] cols = this.VisibleColumns;
for (int i = 0; i < cols.Length; i++)
{
if (cols[i].CustomOrderAllowed)
return InitOrderDisplayName(new EFPDataViewOrder(cols[i].Name));
}
return null;
}
}
/// <summary>
/// Возвращает true, если указанный порядок сортировки можно получить, нажимая на заголовки столбцов просмотра.
/// Свойство EFPDataGidView.CustomOrderActive не проверяется. Учитываются только свойства столбцов EFPDatGridViewColumn.CustomOrderColumnName
///
/// Никаких изменений в просмотре не происходит
/// </summary>
/// <param name="order">Проверяемый порядок</param>
/// <returns>Возможность его выбора</returns>
public bool IsSelectableCustomOrder(EFPDataViewOrder order)
{
if (order == null)
return false;
// Словарик столбцов для сортировки
Dictionary<string, EFPDataGridViewColumn> columnsForSort = new Dictionary<string, EFPDataGridViewColumn>();
foreach (EFPDataGridViewColumn col in Columns)
{
if (col.CustomOrderAllowed)
columnsForSort[col.CustomOrderColumnName] = col;
}
string[] colNames = DataTools.GetDataViewSortColumnNames(order.Sort);
for (int i = 0; i < colNames.Length; i++)
{
if (!columnsForSort.ContainsKey(colNames[i]))
return false;
}
return true;
}
#endregion
#region Общее
/// <summary>
/// Текущий порядок сортировки строк.
/// Содержит один из элементов в списке Orders, если используется предопределенная сортировка.
/// Если используется произвольная сортировка, содержит актуальный объект EFPDataViewOrder.
/// Установка свойства не меняет значения CustomOrderActive. Если CustomOrderActive имеет значение false,
/// то присваиваимое значение должно быть из списка Orders. Если CustomOrderActive имеет значение true,
/// то присваиваимое значение может быть любым, включая null. Переключения на предопределенную сортировку
/// не будет, даже если значение совпадает с одним из элементов списка Orders.
/// </summary>
public EFPDataViewOrder CurrentOrder
{
get { return _CurrentOrder; }
set
{
if (CustomOrderActive)
{
_CurrentOrder = value;
InternalSetCurrentOrder();
}
else
{
if (value == null) // 20.07.2021
{
_CurrentOrder = value;
InternalSetCurrentOrder();
}
else
{
int p = Orders.IndexOf(value);
if (p < 0)
throw new ArgumentException("Значение отсутствует в коллекции Orders", "value");
CurrentOrderIndex = p;
}
}
}
}
private EFPDataViewOrder _CurrentOrder;
/// <summary>
/// Текущий порядок сортировки строк в виде текста
/// </summary>
public string CurrentOrderName
{
get
{
if (CurrentOrder == null)
return String.Empty;
else
return CurrentOrder.Name;
}
set
{
if (String.IsNullOrEmpty(value))
return;
if (CustomOrderActive)
{
if (String.IsNullOrEmpty(value))
CurrentOrder = null;
else
{
string[] requiredColumns = DataTools.GetDataViewSortColumnNames(value);
bool ok = true;
for (int i = 0; i < requiredColumns.Length; i++)
{
EFPDataGridViewColumn col = Columns[requiredColumns[i]];
if (col == null)
{
ok = false;
break;
}
else if (!col.CustomOrderAllowed)
{
ok = false;
break;
}
}
if (ok)
CurrentOrder = InitOrderDisplayName(new EFPDataViewOrder(value));
else
CurrentOrder = null;
}
}
else
{
for (int i = 0; i < Orders.Count; i++)
{
if (Orders[i].Name == value)
{
CurrentOrderIndex = i;
break;
}
}
}
}
}
/// <summary>
/// Это извещение посылается после установки нового значения свойства
/// CurrentOrderIndex (или CurrentOrder / CurrentOrderName)
/// </summary>
public event EventHandler CurrentOrderChanged;
/// <summary>
/// Вызывается после установки нового значения свойства
/// CurrentOrderIndex (или CurrentOrder / CurrentOrderName).
/// Непереопределенный метод вызывает событие CurrentOrderChanged.
/// </summary>
/// <param name="args">Пустой аргумент</param>
protected virtual void OnCurrentOrderChanged(EventArgs args)
{
if (CurrentOrderChanged != null)
CurrentOrderChanged(this, args);
}
/// <summary>
/// Это событие должно обрабатывать установку порядка строк
/// Событие не вызывается, если установлено свойство AutoSort или
/// если вызывается метод PerformRefresh.
/// Поэтому, обработчик Refresh также должен устанвливать порядок строки
/// </summary>
public event EventHandler OrderChanged;
/// <summary>
/// Вызывает событие OrderChanged
/// </summary>
/// <param name="args">Пустой аргумент</param>
protected virtual void OnOrderChanged(EventArgs args)
{
if (OrderChanged != null)
OrderChanged(this, args);
}
/// <summary>
/// Если установить значение этого свойства в true, то будет вызываться событие
/// Refresh при изменении порядка строк.
/// </summary>
public bool OrderChangesToRefresh { get { return _OrderChangesToRefresh; } set { _OrderChangesToRefresh = value; } }
private bool _OrderChangesToRefresh;
private bool _CustomOrderAutoActivated;
/// <summary>
/// Проверяет текущее значение CurrentOrder.
/// Если в таблице нет полей, необходимых для сортировки,
/// то устанавливается новое значение CurrentOrder.
/// Также может измениться значение CustomOrderActive.
///
/// Метод вызывается после присоединения к просмотру таблицы данных
/// </summary>
private void ValidateCurrentOrder()
{
#if DEBUG
if (SourceAsDataTable == null)
throw new InvalidOperationException("SourceAsDataTable==null");
//if (!AutoSort)
// throw new InvalidOperationException("AutoSort=false");
#endif
if (CustomOrderActive)
{
if (_CustomOrderAutoActivated && Orders.Count > 0)
{
string[] tableColumnNames = DataTools.GetColumnNames(SourceAsDataTable);
if (Orders[0].AreAllColumnsPresented(tableColumnNames))
{
CurrentOrderIndex = 0;
return;
}
}
if (CurrentOrder != null)
{
string[] tableColumnNames = DataTools.GetColumnNames(SourceAsDataTable);
if (CurrentOrder.AreAllColumnsPresented(tableColumnNames))
return;
}
bool oldCustomOrderAutoActivated = _CustomOrderAutoActivated;
CurrentOrder = DefaultCustomOrder;
_CustomOrderAutoActivated = oldCustomOrderAutoActivated;
}
else
{
if (CurrentOrder != null)
{
string[] tableColumnNames = DataTools.GetColumnNames(SourceAsDataTable);
if (CurrentOrder.AreAllColumnsPresented(tableColumnNames))
return;
}
else if (OrderCount > 0)
{
string[] tableColumnNames = DataTools.GetColumnNames(SourceAsDataTable);
if (Orders[0].AreAllColumnsPresented(tableColumnNames))
{
CurrentOrderIndex = 0;
return;
}
}
if (CustomOrderAllowed)
{
EFPDataViewOrder defOrd = DefaultCustomOrder;
if (defOrd == null)
CurrentOrder = null; // не устанавливаем CustomOrderActive=true;
else
{
CustomOrderActive = true;
CurrentOrder = defOrd;
}
_CustomOrderAutoActivated = true;
}
}
}
/// <summary>
/// Если установить свойство в true, то не будет вызываться событие CurrentOrderChanged
/// Вместо этого при переключении порядка сортировки пользователеми будет
/// вызываться метод PerformAutoSort() для установки значения DataView.ViewOrder
/// </summary>
public bool AutoSort { get { return _AutoSort; } set { _AutoSort = value; } }
private bool _AutoSort;
private static bool _Inside_PerformAutoSort; // 09.09.2020
/// <summary>
/// Установить значение DataView.ViewOrder
/// Используйте этот метод в событии Refresh
/// </summary>
public void PerformAutoSort()
{
if (_Inside_PerformAutoSort)
return;
_Inside_PerformAutoSort = true;
try
{
if (Visible && HasBeenCreated)
{
if (SelectedRowsMode == EFPDataGridViewSelectedRowsMode.None || SelectedRowsMode == EFPDataGridViewSelectedRowsMode.RowIndex)
DoPerformAutoSort(); // не восстанавливаем выбранную позицию
else
{
EFPDataGridViewSelection oldSel = this.Selection;
DoPerformAutoSort();
this.Selection = oldSel;
}
}
else
DoPerformAutoSort(); // не восстанавливаем выбранную позицию
}
finally
{
_Inside_PerformAutoSort = false;
}
}
private void DoPerformAutoSort()
{
if (CurrentOrder == null)
SourceAsDataView.Sort = String.Empty; // 16.07.2021
else
CurrentOrder.PerformSort(this);
}
void Control_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs args)
{
try
{
DoControl_ColumnHeaderMouseClick(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка нажатия мыши на заголовке табличного просмотра");
}
}
void DoControl_ColumnHeaderMouseClick(DataGridViewCellMouseEventArgs args)
{
EFPApp.ShowTempMessage(null);
if (args.ColumnIndex < 0)
return;
if (args.Button != MouseButtons.Left)
return;
string clickedColumnName = Columns[args.ColumnIndex].Name;
if (String.IsNullOrEmpty(clickedColumnName))
return; // на всякий случай
bool res;
if (CustomOrderActive)
res = DoControl_ColumnHeaderMouseClickCustom(clickedColumnName);
else
res = DoControl_ColumnHeaderMouseClickPredefined(clickedColumnName);
if (res)
{
// 01.07.2021
// Если в просмотре выделена ячейка, которая не видна на экране на момент щелчка, то после сортировки
// просмотр будет прокручен, чтобы эта ячейка попала в просмотр.
// Это может быть неудобно.
// По возможности, переключаемся на ячейку, по которой щелнкули
switch (Control.SelectionMode)
{
case DataGridViewSelectionMode.CellSelect:
case DataGridViewSelectionMode.RowHeaderSelect:
if (IsCurrentRowSingleSelected)
CurrentColumnName = clickedColumnName;
break;
case DataGridViewSelectionMode.FullColumnSelect:
CurrentColumnName = clickedColumnName;
break;
}
}
}
private bool DoControl_ColumnHeaderMouseClickPredefined(string clickedColumnName)
{
if (OrderCount == 0)
{
if (CustomOrderAllowed)
{
EFPApp.ShowTempMessage("Нет предопределенных порядков сортировки. Переключитесь на произвольный порядок строк");
return false;
}
else
{
EFPApp.ShowTempMessage("Сортировка не предусмотрена");
return false;
}
}
if (CurrentOrderIndex >= 0)
{
if (GetUsedColumnName(Orders[CurrentOrderIndex]) == clickedColumnName)
{
// Щелкнутый столбец уже является текущим столбцом сортировки
for (int i = CurrentOrderIndex + 1; i < Orders.Count; i++)
{
if (GetUsedColumnName(Orders[i]) == clickedColumnName)
{
// Есть еще один такой столбец
CurrentOrderIndex = i;
return true;
}
}
for (int i = 0; i < CurrentOrderIndex; i++)
{
if (GetUsedColumnName(Orders[i]) == clickedColumnName)
{
// Есть еще один такой столбец
CurrentOrderIndex = i;
return false;
}
}
EFPApp.ShowTempMessage("Строки уже отсортированы по этому столбцу");
return false;
}
}
int OrderIndex = Orders.IndexOfItemForGridColumn(clickedColumnName);
if (OrderIndex >= 0)
{
CurrentOrderIndex = OrderIndex;
return true;
}
EFPApp.ShowTempMessage("Для этого столбца нет сортировки. Выберите порядок строк из меню");
return false;
}
private bool DoControl_ColumnHeaderMouseClickCustom(string clickedColumnName)
{
EFPDataGridViewColumn col = Columns[clickedColumnName];
if (!col.CustomOrderAllowed)
{
EFPApp.ShowTempMessage("Нельзя выполнять сортировку по столбцу " + col.GridColumn.HeaderText);
return false;
}
bool subMode = (System.Windows.Forms.Control.ModifierKeys == Keys.Control);
string[] currColNames;
ListSortDirection[] currDirs;
DataTools.GetDataViewSortColumnNames(CurrentOrderName, out currColNames, out currDirs);
if (subMode)
{
if (currColNames.Length == 0)
{
EFPApp.ShowTempMessage("В данный момент сортировка не выполнена. Не нажимайте <Ctrl>");
return false;
}
if (currColNames[currColNames.Length - 1] == col.CustomOrderColumnName)
{
// Переключаем направление
InvertLastSortDirection(currDirs);
CurrentOrder = InitOrderDisplayName(new EFPDataViewOrder(DataTools.GetDataViewSort(currColNames, currDirs)));
return true;
}
if (Array.IndexOf<string>(currColNames, col.CustomOrderColumnName) >= 0)
{
EFPApp.ShowTempMessage("Нельзя добавить столбец к сортировке, так как он уже в ней участвует");
return false;
}
currColNames = DataTools.MergeArrays<string>(currColNames, new string[] { col.CustomOrderColumnName });
currDirs = DataTools.MergeArrays<ListSortDirection>(currDirs, new ListSortDirection[] { ListSortDirection.Ascending });
CurrentOrder = InitOrderDisplayName(new EFPDataViewOrder(DataTools.GetDataViewSort(currColNames, currDirs)));
}
else
{
if (currColNames.Length == 1)
{
if (currColNames[0] == col.CustomOrderColumnName)
{
InvertLastSortDirection(currDirs);
CurrentOrder = InitOrderDisplayName(new EFPDataViewOrder(DataTools.GetDataViewSort(currColNames, currDirs)));
return true;
}
}
CurrentOrder = InitOrderDisplayName(new EFPDataViewOrder(col.CustomOrderColumnName));
}
return true;
}
private static void InvertLastSortDirection(ListSortDirection[] currDirs)
{
if (currDirs[currDirs.Length - 1] == ListSortDirection.Ascending)
currDirs[currDirs.Length - 1] = ListSortDirection.Descending;
else
currDirs[currDirs.Length - 1] = ListSortDirection.Ascending;
}
private EFPDataViewOrder InitOrderDisplayName(EFPDataViewOrder order)
{
order.DisplayName = GetOrderDisplayName(order);
return order;
}
/// <summary>
/// Возвращает подходящее отображаемое имя для произвольного порядка сортировки.
/// Используются заголовки столбцов табличного просмотра.
/// </summary>
/// <param name="order">Произвольный порядок сортировки</param>
/// <returns>Отображаемое название</returns>
public string GetOrderDisplayName(EFPDataViewOrder order)
{
if (order == null)
return String.Empty;
// Словарик столбцов для сортировки
Dictionary<string, EFPDataGridViewColumn> columnsForSort = new Dictionary<string, EFPDataGridViewColumn>();
foreach (EFPDataGridViewColumn col in Columns)
{
if (col.CustomOrderAllowed)
columnsForSort[col.CustomOrderColumnName] = col;
}
string[] colNames;
ListSortDirection[] dirs;
DataTools.GetDataViewSortColumnNames(order.Sort, out colNames, out dirs);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < colNames.Length; i++)
{
if (i > 0)
sb.Append(", ");
EFPDataGridViewColumn col;
if (columnsForSort.TryGetValue(colNames[i], out col))
sb.Append(col.DisplayName);
else
sb.Append(colNames[i]);
if (colNames.Length == 1)
{
if (dirs[i] == ListSortDirection.Ascending)
sb.Append(" (по возрастанию)");
else
sb.Append(" (по убыванию)");
}
else
{
if (dirs[i] == ListSortDirection.Ascending)
sb.Append(" (возр.)");
else
sb.Append(" (убыв.)");
}
}
return sb.ToString();
}
/// <summary>
/// Должен ли EFPDataGridView управлять свойствами DataGridViewColumn.SortMode и DataGridViewColumnHeaderCell.SortGlyphDirection
/// для рисования треугольников в заголовках столбцов, и выполнять сортировку по нажатию кнопки мыши.
/// По умолчанию - true - обработка разрешена. При этом, если OrderCount=0 и CustomOrderAllowed=false,
/// щелчок по заголовку выдает сообщение в статусной строке "Сортировка невозможна".
/// Установка значения false восстанавливает поведение DataGridView по умолчанию для автоматической сортировки.
/// Свойство можно устанавливать только до появления события Created.
/// </summary>
public bool UseColumnHeaderClick
{
get { return _UseColumnHeaderClick; }
set
{
CheckHasNotBeenCreated();
_UseColumnHeaderClick = value;
}
}
private bool _UseColumnHeaderClick;
/// <summary>
/// Инициализация свойства DataGridViewColumn.SortMode для всех столбцов
/// </summary>
private void InitColumnSortMode()
{
if (!UseColumnHeaderClick)
return;
if (CustomOrderActive)
{
foreach (EFPDataGridViewColumn col in Columns)
{
if (col.CustomOrderAllowed)
col.GridColumn.SortMode = DataGridViewColumnSortMode.Programmatic;
else
col.GridColumn.SortMode = DataGridViewColumnSortMode.NotSortable;
}
}
else
{
foreach (EFPDataGridViewColumn col in Columns)
col.GridColumn.SortMode = DataGridViewColumnSortMode.NotSortable;
foreach (EFPDataViewOrder order in Orders)
{
EFPDataGridViewColumn col = GetUsedColumn(order);
if (col != null)
col.GridColumn.SortMode = DataGridViewColumnSortMode.Programmatic;
}
}
CommandItems.InitOrderItems();
InitColumnHeaderTriangles();
}
/// <summary>
/// Прорисовка трегольников сортировки в заголовках столбов в соответствии с
/// текущим порядком сортировки CurrentOrder
/// </summary>
private void InitColumnHeaderTriangles()
{
if (ProviderState != EFPControlProviderState.Attached)
return;
if (!UseColumnHeaderClick)
return;
foreach (DataGridViewColumn Col in Control.Columns)
Col.HeaderCell.SortGlyphDirection = SortOrder.None;
if (CurrentOrder != null)
{
if (CustomOrderActive)
{
// Словарик столбцов для сортировки
Dictionary<string, EFPDataGridViewColumn> columnsForSort = new Dictionary<string, EFPDataGridViewColumn>();
foreach (EFPDataGridViewColumn col in Columns)
{
if (col.CustomOrderAllowed)
columnsForSort[col.CustomOrderColumnName] = col;
}
string[] columnNames;
ListSortDirection[] directions;
DataTools.GetDataViewSortColumnNames(CurrentOrder.Sort, out columnNames, out directions);
for (int i = 0; i < columnNames.Length; i++)
{
EFPDataGridViewColumn Col;
if (columnsForSort.TryGetValue(columnNames[i], out Col))
{
try
{
if (directions[i] == ListSortDirection.Descending)
Col.GridColumn.HeaderCell.SortGlyphDirection = SortOrder.Descending;
else
Col.GridColumn.HeaderCell.SortGlyphDirection = SortOrder.Ascending;
}
catch (Exception e)
{
e.Data["DislayName"] = this.DisplayName;
e.Data["ColumnName"] = Col.Name;
e.Data["CustomOrderActive"] = CustomOrderActive;
try
{
Form frm = Control.FindForm();
if (frm != null)
e.Data["Form"] = frm.ToString();
}
catch { }
FreeLibSet.Logging.LogoutTools.LogoutException(e, "Ошибка установки DataGridViewColumn.SortGlyphDirection");
}
}
}
}
else // предопределенная конфигурация
{
EFPDataGridViewColumn Col = GetUsedColumn(CurrentOrder);
if (Col != null && Col.GridColumn.SortMode != DataGridViewColumnSortMode.NotSortable)
{
try
{
if (CurrentOrder.SortInfo.Direction == ListSortDirection.Descending)
Col.GridColumn.HeaderCell.SortGlyphDirection = SortOrder.Descending;
else
Col.GridColumn.HeaderCell.SortGlyphDirection = SortOrder.Ascending;
}
catch (Exception e)
{
e.Data["DislayName"] = this.DisplayName;
e.Data["ColumnName"] = Col.Name;
e.Data["CustomOrderActive"] = CustomOrderActive;
try
{
Form frm = Control.FindForm();
if (frm != null)
e.Data["Form"] = frm.ToString();
}
catch { }
FreeLibSet.Logging.LogoutTools.LogoutException(e, "Ошибка установки DataGridViewColumn.SortGlyphDirection");
}
}
}
}
}
/// <summary>
/// Показать диалог выбора порядка строк из массива Orders
/// Если пользователь выбирает порядок, то устанавливается свойство CurrentOrder
/// </summary>
/// <returns></returns>
public bool ShowSelectOrderDialog()
{
#if XXX
if (OrderCount == 0)
{
EFPApp.ShowTempMessage("Нельзя выбрать порядок строк в табличном просмотре");
return false;
}
int idx = CurrentOrderIndex;
if (!Orders.ShowSelectDialog(ref idx))
return false;
CurrentOrderIndex = idx;
return true;
#else
if (OrderCount == 0 && (!CustomOrderAllowed))
{
EFPApp.ShowTempMessage("Нельзя выбрать порядок строк в табличном просмотре");
return false;
}
return EFPDataGridViewOrderForm.PerformSort(this);
#endif
}
#endregion
#endregion
#region Индекс используемого столбца для порядка сортировки
/// <summary>
/// Возвращает индекс столбца табличного просмотра (DataGridViewColumn.Index), который будет использоваться для щелчка мыши для заданного порядка сортировки.
/// Если в просмотре нет ни одного подходящего столбца, возвращается (-1)
/// </summary>
/// <param name="item">Порядок сортировки</param>
/// <returns>Индекс столбца</returns>
public int IndexOfUsedColumnName(EFPDataViewOrder item)
{
if (item == null)
return (-1);
if (item.SortInfo.IsEmpty)
return -1;
int BestColumnIndex = -1;
int BestDisplayIndex = -1;
for (int i = 0; i < item.SortInfo.ClickableColumnNames.Length; i++)
{
int ColumnIndex = Columns.IndexOf(item.SortInfo.ClickableColumnNames[i]);
if (ColumnIndex < 0)
continue;
DataGridViewColumn Col = Control.Columns[ColumnIndex];
if (!Col.Visible)
continue; // скрытые столбцы не считаются
int DisplayIndex = Col.DisplayIndex;
if (BestColumnIndex < 0 || DisplayIndex < BestDisplayIndex)
{
BestColumnIndex = ColumnIndex;
BestDisplayIndex = DisplayIndex;
}
}
return BestColumnIndex;
}
/// <summary>
/// Возвращает имя столбца табличного просмотра (EFPDataGridViewColumn.Name), который будет использоваться для щелчка мыши для заданного порядка сортировки.
/// Если в просмотре нет ни одного подходящего столбца, возвращается пустая строка
/// </summary>
/// <param name="item">Порядок сортировки</param>
/// <returns>Индекс столбца</returns>
public string GetUsedColumnName(EFPDataViewOrder item)
{
int p = IndexOfUsedColumnName(item);
if (p < 0)
return String.Empty;
else
return Columns[p].Name;
}
/// <summary>
/// Возвращает столбец EFPDataGridViewColumn, который будет использоваться для щелчка мыши для заданного порядка сортировки.
/// Если в просмотре нет ни одного подходящего столбца, возвращается null
/// </summary>
/// <param name="item">Порядок сортировки</param>
/// <returns>Индекс столбца</returns>
public EFPDataGridViewColumn GetUsedColumn(EFPDataViewOrder item)
{
int p = IndexOfUsedColumnName(item);
if (p < 0)
return null;
else
return Columns[p];
}
#endregion
#region Команды локального меню
/// <summary>
/// Список команд локального меню.
/// </summary>
public new EFPDataGridViewCommandItems CommandItems { get { return (EFPDataGridViewCommandItems)(base.CommandItems); } }
/// <summary>
/// Создает EFPDataGridViewCommandItems
/// </summary>
/// <returns></returns>
protected override EFPControlCommandItems GetCommandItems()
{
return new EFPDataGridViewCommandItems(this);
}
/// <summary>
/// Делает командой, выделенной по умолчанию, команду "Edit" или "View"
/// </summary>
protected override void OnBeforePrepareCommandItems()
{
base.OnBeforePrepareCommandItems();
if ((!CommandItems.EnterAsOk) && CommandItems.DefaultCommandItem == null)
{
EFPCommandItem ci = CommandItems["Edit", "Edit"];
if (ci.Visible)
CommandItems.DefaultCommandItem = ci;
else
{
ci = CommandItems["Edit", "View"];
if (ci.Visible)
CommandItems.DefaultCommandItem = ci;
}
}
//// 01.12.2020
//// При выполнением
//CommandItems.AddClickHandler(ResetCurrentIncSearchColumn);
}
#endregion
#region Поддержка Inline-редактирования
/// <summary>
/// Встроенное выполнение операций редактирования без использования
/// внешних обработчиков.
/// Поддерживаются режимы "Редактирование" и "Удаление"
/// В режиме Edit вызывается DataGridView.BeginEdit(), при этом проверяются свойства ReadOnly
/// </summary>
/// <param name="state">Edit или Delete</param>
public void InlineEditData(EFPDataGridViewState state)
{
switch (state)
{
case EFPDataGridViewState.Edit:
// 09.01.2013
// Лучше лишний раз проверить режим ReadOnly и выдать ShowTempMessage(),
// т.к. обычный BeginEdit() не будет выдавать сообщение, если для столбца
// установлено ReadOnly=true
if (Control.IsCurrentCellInEditMode)
{
EFPApp.ShowTempMessage("Ячейка уже редактируется");
return;
}
string ReadOnlyMessage;
if (GetCellReadOnly(Control.CurrentCell, out ReadOnlyMessage))
{
EFPApp.ShowTempMessage(ReadOnlyMessage);
return;
}
Control.BeginEdit(true);
break;
case EFPDataGridViewState.Delete:
if (WholeRowsSelected && Control.AllowUserToDeleteRows)
{
DataGridViewRow[] Rows = SelectedGridRows;
if (Rows.Length == 0)
EFPApp.ShowTempMessage("Нет выбранных строк для удаления");
else
{
for (int i = 0; i < Rows.Length; i++)
Control.Rows.Remove(Rows[i]);
}
}
else
ClearSelectedCells();
break;
default:
EFPApp.ShowTempMessage("Редактирование по месту для режима \"" +
state.ToString() + "\" не реализовано");
break;
}
}
/// <summary>
/// Очищает значения в выбранных ячейках.
/// Если хотя бы одна из ячеек не разрешает редактирование, выдается сообщение
/// об ошибке и выделяется эта ячейка
/// </summary>
public void ClearSelectedCells()
{
EFPDataGridViewRectArea Area = new EFPDataGridViewRectArea(Control, EFPDataGridViewRectAreaCreation.Selected);
ClearCells(Area);
}
/// <summary>
/// Очищает значения в указанной области ячеек.
/// Если хотя бы одна из ячеек не разрешает редактирование, выдается сообщение
/// об ошибке и выделяется эта ячейка.
/// </summary>
/// <param name="area">Область строк и столбцов</param>
public void ClearCells(EFPDataGridViewRectArea area)
{
if (area.IsEmpty)
{
EFPApp.ShowTempMessage("Нет выбранных ячеек");
return;
}
#region Первый проход. Проверяем возможность удаления
// Проверяем, что мы можем записать пустой текст во все ячейки
for (int i = 0; i < area.RowCount; i++)
{
for (int j = 0; j < area.ColumnCount; j++)
{
DataGridViewCell Cell = area[j, i];
if (!Cell.Selected)
continue;
string ErrorText;
if (GetCellReadOnly(Cell, out ErrorText))
{
Control.CurrentCell = Cell;
EFPApp.ShowTempMessage(ErrorText);
return;
}
if (!TrySetTextValue(Cell, String.Empty, out ErrorText, true, EFPDataGridViewCellFinishedReason.Clear))
{
Control.CurrentCell = Cell;
EFPApp.ShowTempMessage(ErrorText);
return;
}
}
}
#endregion
#region Второй проход. Удаляем значения
for (int i = 0; i < area.Rows.Count; i++)
{
for (int j = 0; j < area.Columns.Count; j++)
{
DataGridViewCell Cell = area[j, i];
if (!Cell.Selected)
continue;
SetTextValue(Cell, String.Empty, EFPDataGridViewCellFinishedReason.Edit);
}
}
#endregion
}
/*
* Проблема.
* Если просмотр находится в режиме inline-редактирования (в ячейке), а форма,
* на которой расположен просмотр, имеет кнопку "Отмена" (установлено свойство
* TheForm.CancelButton), то при нажатии пользователем клавиши Esc, вместо отмены
* редактирования и возврата к навигации по ячейкам, как ожидалось,
* редактирование ячейки сохраняется, а форма закрывается.
*
* Где перехватить нажатие клавиши Esc - неизвестно.
*
* Решение.
* На время нахождения просмотра в режиме inline-редактирования будем отключать
* свойство TheForm.CancelButton, не забывая его восстановить. Для этого
* обрабатываем события CellBeginEdit и CellEndEdit. Первое из них имеет поле
* Cancel, которое позволяет не начинать редактирование. В этом случае отключение
* кнопки "Отмена" не должно выполняться, т.к. иначе форма перестанет реагировать
* на Esc совсем. Следовательно, наш обработчик события CellBeginEdit должен
* располагаться в конце цепочки обработчиков, чтобы можно было анализировать
* поле Args.Cancel. Поэтому обработчик присоедияется не в конструкторе объекта,
* а в методе SetCommandItems()
*
*/
void Control_CellBeginEdit1(object sender, DataGridViewCellCancelEventArgs args)
{
try
{
DoControl_CellBeginEdit1(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_CellBeginEdit");
}
}
void DoControl_CellBeginEdit1(DataGridViewCellCancelEventArgs args)
{
if (args.Cancel)
return;
if (args.ColumnIndex < 0)
return; // никогда не бывает
string ReadOnlyMessage;
bool RO = GetCellReadOnly(args.RowIndex, args.ColumnIndex, out ReadOnlyMessage);
if (RO)
{
args.Cancel = true;
DataGridViewColumn Column = Control.Columns[args.ColumnIndex];
if (!(Column is DataGridViewCheckBoxColumn))
EFPApp.ShowTempMessage(ReadOnlyMessage);
}
}
/// <summary>
/// Сохраняем свойство Form.CancelButton на время редактирования ячейки "по месту", чтобы
/// нажатие клавиши "Esc" не приводило сразу к закрытию кнопки
/// </summary>
private IButtonControl _SavedCancelButton;
void Control_CellBeginEdit2(object sender, DataGridViewCellCancelEventArgs args)
{
try
{
DoControl_CellBeginEdit2(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_CellBeginEdit");
}
}
void DoControl_CellBeginEdit2(DataGridViewCellCancelEventArgs args)
{
if (args.Cancel)
return;
if (args.ColumnIndex < 0)
return; // никогда не бывает
DataGridViewColumn Column = Control.Columns[args.ColumnIndex];
if (Column is DataGridViewCheckBoxColumn) // 04.11.2009 - для CheckBox-не надо
return;
_SavedCancelButton = Control.FindForm().CancelButton;
Control.FindForm().CancelButton = null;
}
#if XXX
void Control_CellEndEdit1(object Sender, DataGridViewCellEventArgs Args)
{
try
{
DoControl_CellEndEdit1(Args);
}
catch (Exception e)
{
DebugTools.ShowException(e, "Control_CellEndEdit");
}
}
void DoControl_CellEndEdit1(DataGridViewCellEventArgs Args)
{
}
#endif
void Control_CellEndEdit2(object sender, DataGridViewCellEventArgs args)
{
try
{
if (_SavedCancelButton != null)
{
Control.FindForm().CancelButton = _SavedCancelButton;
_SavedCancelButton = null;
}
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_CellEndEdit");
}
}
void Control_CellContentClick(object sender, DataGridViewCellEventArgs args)
{
// Обработка столбцов флажков
// Стандартное поведение неудобно. При нажатии на флажок, строка переходит
// в режим редактирования, при этом значение не будет передано в набор данных,
// пока пользователь не перейдет к другой строке
try
{
DoControl_CellContentClick(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка обработки щелчка мыши на содержимом ячейки табличного просмотра");
}
}
private void DoControl_CellContentClick(DataGridViewCellEventArgs args)
{
if (args.RowIndex < 0 || args.ColumnIndex < 0)
return;
if (Control[args.ColumnIndex, args.RowIndex] is DataGridViewCheckBoxCell)
{
string ReadOnlyMessage;
bool RO = GetCellReadOnly(args.RowIndex, args.ColumnIndex, out ReadOnlyMessage);
if (RO && GetCellContentVisible(args.RowIndex, args.ColumnIndex))
EFPApp.ShowTempMessage(ReadOnlyMessage);
}
}
private void Control_CurrentCellDirtyStateChanged(object sender, EventArgs args)
{
try
{
if (Control.CurrentCell is DataGridViewCheckBoxCell || Control.CurrentCell is DataGridViewComboBoxCell)
Control.CommitEdit(DataGridViewDataErrorContexts.Commit);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка обработки события CurrentCellDirtyStateChanged");
}
}
void Control_CellParsing(object sender, DataGridViewCellParsingEventArgs args)
{
try
{
DoControl_CellParsing(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка обработки события CellParsing");
}
}
private void DoControl_CellParsing(DataGridViewCellParsingEventArgs args)
{
if (args.ParsingApplied)
return;
DataGridViewCell Cell = Control[args.ColumnIndex, args.RowIndex];
if (Cell is DataGridViewTextBoxCell)
{
if (args.Value is String)
{
// 16.08.2012
// Разрешаем пользователю затирать значение ячейки не только нажатием <Ctrl>+<0>,
// но и пробелом. При этом введенное значение равно " " (или строка из нескольких
// пробелов).
// Я не знаю, как это сделать красивее, т.к. требуется преобразовать Value
// к заданному типу. Нельзя сделать Value=InheritedCellStyle.NullValue,
// т.к. в этом случае все равно будет вызван стандартный обработчик, который
// преобразует исходную строку еще раз
string s = args.Value.ToString().Trim();
if (s.Length == 0)
{
args.InheritedCellStyle.NullValue = args.Value;
args.ParsingApplied = false;
}
else TryParseNumbers(s, args);
}
}
}
/// <summary>
/// 13.12.2012
/// Попытка преобразовать числа с плавающей точкой.
/// Замена "." на "," или наоборот
/// </summary>
/// <param name="s"></param>
/// <param name="args"></param>
private bool TryParseNumbers(string s, DataGridViewCellParsingEventArgs args)
{
if (!DataTools.IsFloatType(args.DesiredType))
return false; // не число с плавающей точкой
WinFormsTools.CorrectNumberString(ref s, args.InheritedCellStyle.FormatProvider);
DataGridViewCell Cell = Control[args.ColumnIndex, args.RowIndex];
try
{
args.Value = Cell.ParseFormattedValue(s, args.InheritedCellStyle, null, null);
}
catch
{
return false;
}
args.ParsingApplied = true;
return true;
}
void Control_CellValidating(object sender, DataGridViewCellValidatingEventArgs args)
{
try
{
DoControl_CellValidating(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка при обработк события CellValidating");
args.Cancel = true;
}
}
private void DoControl_CellValidating(DataGridViewCellValidatingEventArgs args)
{
if (args.Cancel)
return;
DataGridViewCell Cell = Control[args.ColumnIndex, args.RowIndex];
if (!Control.IsCurrentCellInEditMode)
return;
// 15.12.2012
// Проверяем корректность маски
IMaskProvider MaskProvider = Columns[args.ColumnIndex].MaskProvider;
if (MaskProvider != null && Cell.ValueType == typeof(string))
{
string s = args.FormattedValue.ToString().Trim();
if (s.Length > 0)
{
string ErrorText;
if (!MaskProvider.Test(args.FormattedValue.ToString(), out ErrorText))
{
EFPApp.ShowTempMessage(ErrorText);
args.Cancel = true;
}
}
}
}
void Control_CellValueChanged(object sender, DataGridViewCellEventArgs args)
{
try
{
DoControl_CellValueChanged(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка обработки события CellValueChanged");
}
}
private bool InsideCellValueChanged = false;
private void DoControl_CellValueChanged(DataGridViewCellEventArgs Args)
{
if (InsideCellValueChanged)
return;
InsideCellValueChanged = true;
try
{
if (Control.IsCurrentCellInEditMode)
{
if (Control.CurrentCell.RowIndex == Args.RowIndex && Control.CurrentCell.ColumnIndex == Args.ColumnIndex)
{
OnCellFinished(Args.RowIndex, Args.ColumnIndex, EFPDataGridViewCellFinishedReason.Edit);
Control.InvalidateRow(Args.RowIndex);
}
}
}
finally
{
InsideCellValueChanged = false;
}
}
/// <summary>
/// Событие вызывается, когда закончено редактирование ячейки и новое значение
/// Cell.Value установлено (вызывается из CellValueChanged). Событие не
/// вызывается, если пользователь нажал Esc.
/// Обработчик может, например, выполнить расчет других значений строки или
/// расчет итоговой строки.
/// Также событие вызывается после вставки значений из буфера обмена и
/// установки / снятия отметки строки (MarkRow)
/// </summary>
public event EFPDataGridViewCellFinishedEventHandler CellFinished;
private bool _CellFinishedErrorShown = false;
/// <summary>
/// Вызов события CellFinished
/// </summary>
/// <param name="rowIndex"></param>
/// <param name="columnIndex"></param>
/// <param name="reason"></param>
public virtual void OnCellFinished(int rowIndex, int columnIndex, EFPDataGridViewCellFinishedReason reason)
{
if (CellFinished == null)
return;
EFPDataGridViewCellFinishedEventArgs Args = new EFPDataGridViewCellFinishedEventArgs(this,
rowIndex, columnIndex, reason);
try
{
CellFinished(this, Args);
}
catch (Exception e)
{
if (!_CellFinishedErrorShown)
{
_CellFinishedErrorShown = true;
EFPApp.ShowException(e, "Ошибка в обработчике события CellFinished");
}
}
Validate();
}
/// <summary>
/// Возвращает true, если заданная ячейка имеет установленный атрибут "только чтение"
/// </summary>
/// <param name="cell">Ячейка</param>
/// <param name="readOnlyMessage">Сюда помещается текст, почему нельзя редактировать ячейку</param>
/// <returns>true, если ячейку нельзя редактировать</returns>
public bool GetCellReadOnly(DataGridViewCell cell, out string readOnlyMessage)
{
if (cell == null)
{
readOnlyMessage = "Ячейка не выбрана";
return true;
}
return GetCellReadOnly(cell.RowIndex, cell.ColumnIndex, out readOnlyMessage);
}
/// <summary>
/// Возвращает true, если заданная ячейка имеет установленный атрибут "только чтение".
/// В первую очередь вызывается GetRowReadOnly() для проверки атрибута строки.
/// </summary>
/// <param name="rowIndex">Индекс строки</param>
/// <param name="columnIndex">Индекс столбца</param>
/// <param name="readOnlyMessage">Сюда помещается текст, почему нельзя редактировать ячейку</param>
/// <returns>true, если ячейку нельзя редактировать</returns>
public bool GetCellReadOnly(int rowIndex, int columnIndex, out string readOnlyMessage)
{
if (GetRowReadOnly(rowIndex, out readOnlyMessage))
return true;
DoGetCellAttributes(columnIndex);
readOnlyMessage = _GetCellAttributesArgs.ReadOnlyMessage;
return _GetCellAttributesArgs.ReadOnly;
}
/// <summary>
/// Возвращает true, если заданная строка имеет установленный атрибут "только чтение".
/// Также может быть задан атрибут для отдельных ячеек.
/// Обычно следует использовать метод GetCellReadOnly().
/// </summary>
/// <param name="rowIndex">Индекс строки</param>
/// <param name="readOnlyMessage">Сюда помещается текст, почему нельзя редактировать строку</param>
/// <returns>true, если ячейку нельзя редактировать</returns>
public bool GetRowReadOnly(int rowIndex, out string readOnlyMessage)
{
if (Control.ReadOnly)
{
readOnlyMessage = "Просмотр предназначен только для чтения";
return true;
}
if (rowIndex < 0 || rowIndex >= Control.RowCount)
{
readOnlyMessage = "Неправильный номер строки";
return true;
}
DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.ReadOnly);
readOnlyMessage = _GetRowAttributesArgs.ReadOnlyMessage;
return _GetRowAttributesArgs.ReadOnly;
}
/// <summary>
/// Запрашивает атрибуты строки и ячейки в режиме View и возвращает признак
/// ContentVisible.
/// </summary>
/// <param name="rowIndex">Индекс строки</param>
/// <param name="columnIndex">Индекс столбца</param>
/// <returns>false - если содержимое ячейки не должно отображаться</returns>
public bool GetCellContentVisible(int rowIndex, int columnIndex)
{
DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.View);
return DoGetCellAttributes(columnIndex).ContentVisible;
}
#endregion
#region Вставка текста из буфера обмена
/// <summary>
/// Выполняет вставку текста в прямоугольную область.
/// Левая верхняя ячейка области определяется текущем выделением ячейки.
/// Если вставка не может быть выполнена, выдается сообщение об ошибке и возвращается false
/// </summary>
/// <param name="textArray">Вставляемый текст (строки и столбцы)</param>
/// <returns>true, если вставка выполнена</returns>
public bool PerformPasteText(string[,] textArray)
{
string ErrorText;
if (DoPasteText(textArray, false, out ErrorText))
return true;
else
{
EFPApp.ShowTempMessage(ErrorText);
return false;
}
}
/// <summary>
/// Проверяет возможность вставки текста в прямоугольную область.
/// Левая верхняя ячейка области определяется текущем выделением ячейки.
/// </summary>
/// <param name="textArray">Вставляемый текст (строки и столбцы)</param>
/// <returns>true, если вставка может быть выполнена</returns>
public bool TestCanPasteText(string[,] textArray)
{
string ErrorText;
return TestCanPasteText(textArray, out ErrorText);
}
/// <summary>
/// Проверяет возможность вставки текста в прямоугольную область.
/// Левая верхняя ячейка области определяется текущем выделением ячейки.
/// </summary>
/// <param name="textArray">Вставляемый текст (строки и столбцы)</param>
/// <param name="errorText">Сюда помещается пояснение, если вставка недоступна</param>
/// <returns>true, если вставка выполнена</returns>
public bool TestCanPasteText(string[,] textArray, out string errorText)
{
return DoPasteText(textArray, true, out errorText);
}
/// <summary>
/// Выполнение вставки текста в прямоугольную область или проверка возможности вставки.
/// </summary>
/// <param name="textArray">Вставляемый текст</param>
/// <param name="testOnly">true - только тестирование</param>
/// <param name="errorText">Сюда записывается сообщение об ошибке</param>
/// <returns>true, если вставка возможна или выполнена</returns>
protected virtual bool DoPasteText(string[,] textArray, bool testOnly, out string errorText)
{
#region DataGridView.ReadOnly
if (Control.ReadOnly)
{
errorText = "Табличный просмотр не допускает редактирование";
return false;
}
#endregion
#region Область вставки
// Прямоугольный массив a содержит значения для вставки
int nY1 = textArray.GetLength(0);
int nX1 = textArray.GetLength(1);
if (nX1 == 0 || nY1 == 0)
{
errorText = "Текст не задан";
return false; // 27.12.2020
}
Rectangle Rect = SelectedRectAddress;
int nX2 = Rect.Width;
int nY2 = Rect.Height;
if (nX2 == 0 || nY2 == 0)
{
errorText = "Нет выбранной ячейки";
return false;
}
if (nX2 > 1 || nY2 > 1)
{
// В текущий момент выбрано больше одной ячейки.
// Текст в буфере должен укладываться ровное число раз
if (nX1 > nX2 || nY1 > nY2)
{
/*
EFPApp.ShowTempMessage("Текст в буфере обмена содержит " +
RusNumberConvert.IntWithNoun(nY1, "строку", "строки", "строк") + " и " +
RusNumberConvert.IntWithNoun(nX1, "столбец", "столбца", "столбцов") +
", а выбрано меньше: " +
RusNumberConvert.IntWithNoun(nY2, "строка", "строки", "строк") + " и " +
RusNumberConvert.IntWithNoun(nX2, "столбец", "столбца", "столбцов"));
* */
errorText = "Текст в буфере обмена содержит строк: " +
nY1.ToString() + " и столбцов: " + nX1.ToString() +
", а выбрано меньше: строк: " + nY2.ToString() + " и столбцов: " + nX2.ToString();
return false;
}
if ((nX2 % nX1) != 0 || (nY2 % nY1) != 0)
{
/*
EFPApp.ShowTempMessage("Текст в буфере обмена содержит " +
RusNumberConvert.IntWithNoun(nY1, "строку", "строки", "строк") + " и " +
RusNumberConvert.IntWithNoun(nX1, "столбец", "столбца", "столбцов") +
", а выбрано " +
RusNumberConvert.IntWithNoun(nY2, "строка", "строки", "строк") + " и " +
RusNumberConvert.IntWithNoun(nX2, "столбец", "столбца", "столбцов") +
". Не делится нацело");
* */
errorText = "Текст в буфере обмена содержит строк: " +
nY1.ToString() + " и столбцов: " + nX1.ToString() +
", а выбрано строк: " + nY2.ToString() + " и столбцов: " + nX2.ToString() +
". Не делится нацело";
return false;
}
}
else
{
Rect = new Rectangle(Rect.Location, new Size(nX1, nY1));
if (((Rect.Bottom - 1) >= Control.RowCount && (!AutoAddRowsAllowed)) || (Rect.Right - 1) >= Control.ColumnCount)
{
/*
EFPApp.ShowTempMessage("Текст в буфере обмена содержит " +
RusNumberConvert.IntWithNoun(nY1, "строку", "строки", "строк") + " и " +
RusNumberConvert.IntWithNoun(nX1, "столбец", "столбца", "столбцов") +
" - не помещается");
* */
errorText = "Текст в буфере обмена содержит строк: " + nY1.ToString() + " и столбцов:" + nX1.ToString() +
" - не помещается";
return false;
}
if ((!testOnly) && (Rect.Bottom - 1) >= Control.RowCount)
{
int addCount = Rect.Bottom - Control.RowCount + 1;
//int addCount = Rect.Bottom - Control.RowCount + (Control.AllowUserToAddRows ? 0 : 1); // изм. 11.01.2022
#if DEBUG
if (addCount <= 0)
throw new BugException("addCount=" + addCount.ToString());
#endif
AddInsuficientRows(addCount);
}
}
// Rect содержит прямоугольник заменяемых значений
#endregion
#region Опрос свойства ReadOnly ячеек и возможности вставить значения
for (int i = Rect.Top; i < Rect.Bottom; i++)
{
if (testOnly && i >= Control.RowCount)
break;
for (int j = Rect.Left; j < Rect.Right; j++)
{
DataGridViewCell Cell = Control[j, i];
if (GetCellReadOnly(i, j, out errorText))
{
Control.CurrentCell = Cell;
return false;
}
int i1 = (i - Rect.Top) % nY1;
int j1 = (j - Rect.Left) % nX1;
if (!TrySetTextValue(Cell, textArray[i1, j1], out errorText, true, EFPDataGridViewCellFinishedReason.Paste))
{
Control.CurrentCell = Cell;
return false;
}
}
}
#endregion
#region Записываем значение
if (!testOnly)
{
DataGridViewCell oldCell = Control.CurrentCell;
for (int i = Rect.Top; i < Rect.Bottom; i++)
{
for (int j = Rect.Left; j < Rect.Right; j++)
{
DataGridViewCell Cell = Control[j, i];
int i1 = (i - Rect.Top) % nY1;
int j1 = (j - Rect.Left) % nX1;
SetTextValue(Cell, textArray[i1, j1], EFPDataGridViewCellFinishedReason.Paste);
}
}
Control.EndEdit();
// 11.01.2022
// Надо сразу обновить текущую строку, как будто пользователь перешел на другую строку, а потом вернулся обратно.
// Иначе текущая строка оказывается некомплектной и для нее могут возникать ошибки контроля в EFPInputDataGridView.
Control.CurrentCell = null;
Control.CurrentCell = oldCell;
}
#endregion
errorText = null;
return true;
}
/// <summary>
/// Свойство должно возвращать true, если разрешается автоматическое добавление недостающих строк при вставке текста
/// из буфера обмена. При этом должен также быть переопределен метод AddInsuficientRows().
/// Реализовано в классе EFPInputGridView.
/// По умолчанию - false - строки не добавляются.
/// </summary>
protected virtual bool AutoAddRowsAllowed { get { return false; } }
/// <summary>
/// Метод должен добавлять указанное число строк в конец просмотра при вставке текста из буфера обмена.
/// Метод должен быть переопределен, если AutoAddRowsAllowed возвращает true.
/// Реализовано в классе EFPInputGridView.
/// Непереопределенный метод выбрасывает исключение.
/// </summary>
/// <param name="addCount"></param>
protected virtual void AddInsuficientRows(int addCount)
{
throw new NotImplementedException();
}
#endregion
#region События
/// <summary>
/// Вызывается для редактирования данных, просмотра, вставки, копирования
/// и удаления строк
/// </summary>
public event EventHandler EditData;
/// <summary>
/// Вызывает обработчик события EditData и возвращает true, если он установлен
/// Если метод возвращает false, выполняется редактирование "по месту"
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
protected virtual bool OnEditData(EventArgs args)
{
if (EditData != null)
{
EditData(this, args);
return true;
}
else
return false;
}
/// <summary>
/// Вызывается при нажатии кнопки "Обновить", а также при смене
/// фильтра (когда будет реализовано)
/// </summary>
public event EventHandler RefreshData;
/// <summary>
/// Вызывает событие RefreshData.
/// Вызывайте этот метод из OnRefreshData(), если Вы полностью переопределяете его, не вызывая
/// метод базового класса.
/// </summary>
protected void CallRefreshDataEventHandler(EventArgs args)
{
if (RefreshData != null)
RefreshData(this, args);
}
/// <summary>
/// Непереопределенный метод вызывает событие RefreshData.
/// Если метод переопределен, также должно быть переопределено свойство HasRefreshDataHandler
/// </summary>
/// <param name="args"></param>
protected virtual void OnRefreshData(EventArgs args)
{
CallRefreshDataEventHandler(args);
}
/// <summary>
/// Возвращает true, если есть установленный обработчик события RefreshData
/// </summary>
public virtual bool HasRefreshDataHandler { get { return RefreshData != null; } }
bool IEFPDataView.UseRefresh { get { return CommandItems.UseRefresh; } }
/// <summary>
/// Принудительное обновление просмотра.
/// Обновление выполняется, даже если CommandItems.UseRefresh=false.
/// Сохраняется и восстанавливается, если возможно, текущее выделение в просмотре с помощью свойства Selection
/// </summary>
public virtual void PerformRefresh()
{
if (Control.IsDisposed)
return; // 27.03.2018
EFPDataGridViewSelection OldSel = null;
if (ProviderState == EFPControlProviderState.Attached) // 04.07.2021
OldSel = Selection;
#if XXX
for (int i = 0; i < Columns.Count; i++)
// Сброс буферизации GridProducerColumn
{
if (Columns[i].ColumnProducer != null)
Columns[i].ColumnProducer.Refresh();
}
#endif
// Вызов пользовательского события
OnRefreshData(EventArgs.Empty);
IncSearchDataView = null; // больше недействителен (???)
if (OldSel != null)
{
try
{
Selection = OldSel;
}
catch (Exception e)
{
EFPApp.MessageBox("Возникла ошибка при восстановлении выбранных строк при обновлении таблицы. " +
e.Message, "Ошибка табличного просмотра", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
CommandItems.PerformRefreshItems();
}
/// <summary>
/// Вызов метода PerformRefresh(), который можно выполнять из обработчика события
/// </summary>
/// <param name="sender">Игнорируется</param>
/// <param name="args">Игнеорируется</param>
public void PerformRefresh(object sender, EventArgs args)
{
PerformRefresh();
}
#endregion
#region Методы
/// <summary>
/// Перевод просмотра в один из режимов
/// </summary>
public void PerformEditData(EFPDataGridViewState state)
{
if (_InsideEditData)
{
EFPApp.ShowTempMessage("Предыдущее редактирование еще не выполнено");
return;
}
// Любая операция редактирования останавливает поиск по первым буквам
CurrentIncSearchColumn = null;
bool Res;
// Пытаемся вызвать специальный обработчик в GridProducerColum
if (CurrentColumn != null)
{
if (CurrentColumn.ColumnProducer != null)
{
_InsideEditData = true;
_State = state;
try
{
EFPDataViewRowInfo rowInfo = this.GetRowInfo(Control.CurrentCellAddress.Y);
Res = CurrentColumn.ColumnProducer.PerformCellEdit(rowInfo, CurrentColumnName);
FreeRowInfo(rowInfo);
}
finally
{
_State = EFPDataGridViewState.View;
_InsideEditData = false;
}
if (Res)
return;
}
}
_InsideEditData = true;
_State = state;
try
{
Res = OnEditData(EventArgs.Empty);
if (CommandItems != null)
CommandItems.PerformRefreshItems();
}
finally
{
_State = EFPDataGridViewState.View;
_InsideEditData = false;
}
if (!Res)
InlineEditData(state);
}
/// <summary>
/// Предотвращение повторного запуска редактора
/// </summary>
private bool _InsideEditData;
/// <summary>
/// Присвоить текстовое значение ячейке.
/// Операция выполнима, даже если ячейка имеет свойство ReadOnly.
/// Выполняется преобразование в нужный тип данных и проверка коррекстности
/// (соответствие маске, если она задана для столбца). Если преобразование
/// невозможно, вызывается исключение
/// </summary>
/// <param name="cell">Ячейка просмотра</param>
/// <param name="textValue">Записываемое значение</param>
/// <param name="reason">Причина</param>
public void SetTextValue(DataGridViewCell cell, string textValue,
EFPDataGridViewCellFinishedReason reason)
{
string ErrorText;
if (!TrySetTextValue(cell, textValue, out ErrorText, false, reason))
throw new InvalidOperationException("Нельзя записать значение \"" + textValue + "\". " + ErrorText);
}
/// <summary>
/// Попытка присвоить текстовое значение ячейке.
/// Операция считается выполнимой, даже если ячейка имеет свойство ReadOnly.
/// Следует также выполнять проверку методом GetCellReadOnly()
/// Выполняется преобразование в нужный тип данных и проверка корректности
/// (соответствие маске, если она задана для столбца). Если преобразование
/// невозможно, возвращается false и текст сообщения об ошибке
/// </summary>
/// <param name="cell">Ячейка просмотра</param>
/// <param name="textValue">Записываемое значение</param>
/// <param name="errorText">Сюда помещается сообщение об ошибке</param>
/// <param name="testOnly">Если true, то только выполняется проверка возможности записи</param>
/// <param name="reason">Причина</param>
/// <returns>true, если значение успешно записано или могло быть записано</returns>
public bool TrySetTextValue(DataGridViewCell cell, string textValue, out string errorText, bool testOnly,
EFPDataGridViewCellFinishedReason reason)
{
errorText = null;
if (String.IsNullOrEmpty(textValue))
{
if (!testOnly)
{
cell.Value = cell.InheritedStyle.DataSourceNullValue;
OnCellFinished(cell.RowIndex, cell.ColumnIndex, reason);
Control.InvalidateRow(cell.RowIndex);
}
return true;
}
Type ValueType;
if (cell.ValueType != null)
ValueType = cell.ValueType;
else
ValueType = typeof(string);
IMaskProvider MaskProvider = Columns[cell.ColumnIndex].MaskProvider;
if (DataTools.IsFloatType(ValueType))
WinFormsTools.CorrectNumberString(ref textValue);
else if (ValueType == typeof(string) && MaskProvider != null)
{
if (!MaskProvider.Test(textValue, out errorText))
return false;
}
try
{
object v = Convert.ChangeType(textValue, ValueType);
if (!testOnly)
{
if (ValueType == typeof(DateTime))
{
// 30.03.2021, 13.04.2021
// Если формат не предусматривает ввода времени, его требуется убрать
if (!FormatStringTools.ContainsTime(cell.InheritedStyle.Format))
v = ((DateTime)v).Date;
}
cell.Value = v;
OnCellFinished(cell.RowIndex, cell.ColumnIndex, reason);
Control.InvalidateRow(cell.RowIndex);
}
}
catch (Exception e)
{
errorText = e.Message;
return false;
}
return true;
}
#endregion
#region Обработка события DataError
/// <summary>
/// Класс исключения для отладки перехваченной ошибки в событии DataGridView.DataError
/// </summary>
private class DataGridViewDataErrorException : ApplicationException
{
#region Конструктор
public DataGridViewDataErrorException(DataGridView control, DataGridViewDataErrorEventArgs args)
: base("Ошибка DataGridView.DataError (" + args.Context.ToString() + ")", args.Exception)
{
_Control = control;
_Arguments = args;
}
#endregion
#region Свойства
public DataGridView Control { get { return _Control; } }
private readonly DataGridView _Control;
//[DesignerSerializationVisibility(DesignerSerializationVisibility.VisibleEx)]
//public DataGridViewDataErrorEventArgs Arguments { get { return _Arguments; } }
private readonly DataGridViewDataErrorEventArgs _Arguments;
public int RowIndex { get { return _Arguments.RowIndex; } }
public int ColumnIndex { get { return _Arguments.ColumnIndex; } }
public DataGridViewDataErrorContexts Context { get { return _Arguments.Context; } }
#endregion
}
/// <summary>
/// Использовать ли обработку события DataGridView.DataError по умолчанию
/// Если свойство установлено в true, то обработчик события выдает отладочное окно
/// и выводит в log-файл специальный тип исключения о возникшей ошибке.
/// Если свойство установлено в false, то никакие действия не выполняются и
/// сообщения об ошибке не выдается (включая стандартное). При этом предполагается,
/// что имеется дополнительный пользовательский обработчик события DataGridView.DataError,
/// который может вызывать метод DefaultShowDataError() для выдачи сообщения.
/// Значение по умолчанию - true
/// </summary>
public bool UseDefaultDataError { get { return _UseDefaultDataError; } set { _UseDefaultDataError = value; } }
private bool _UseDefaultDataError;
void Control_DataError(object sender, DataGridViewDataErrorEventArgs args)
{
//try
//{
// throw new DataGridViewDataErrorException((DataGridView)Sender, Args);
//}
//catch (Exception Args)
//{
// ShowExceptionForm.ShowException(Args, Args.Message);
//}
try
{
if (UseDefaultDataError)
DefaultShowDataError(sender, args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_DataError");
}
}
private bool _FormatDisplayErrorWasShown = false;
/// <summary>
/// Выдача сообщения об ошибке в обработчике DataGridView.DataError
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void DefaultShowDataError(object sender, DataGridViewDataErrorEventArgs args)
{
DataGridView control = (DataGridView)sender;
if ((args.Context & (DataGridViewDataErrorContexts.Commit | DataGridViewDataErrorContexts.Parsing)) ==
(DataGridViewDataErrorContexts.Commit | DataGridViewDataErrorContexts.Parsing))
{
// Введено неправильное значение в поле. Вместо большого сообщения об ошибке
// выдаем всплывающее сообщение внизу экрана
DataGridViewCell cell = control.Rows[args.RowIndex].Cells[args.ColumnIndex];
EFPApp.ShowTempMessage("Ошибка преобразования введенного значения \"" + cell.EditedFormattedValue.ToString() + "\"");
return;
}
// 16.10.2013
// Для Formatting без Display сообщение тоже выдаем один раз
//if (Args.Context == (DataGridViewDataErrorContexts.Display | DataGridViewDataErrorContexts.Formatting))
if ((args.Context & DataGridViewDataErrorContexts.Formatting) == DataGridViewDataErrorContexts.Formatting)
{
if (_FormatDisplayErrorWasShown)
return; // сообщение выдается только один раз
_FormatDisplayErrorWasShown = true;
Exception e1 = new DataGridViewDataErrorException(control, args);
EFPApp.ShowException(e1, "Ошибка форматирования для ячейки RowIndex=" + args.RowIndex.ToString() + " и ColIndex=" + args.ColumnIndex.ToString());
return;
}
Exception e2 = new DataGridViewDataErrorException(control, args);
EFPApp.ShowException(e2, e2.Message);
}
#endregion
#region Перенаправление событий отдельным столбцам
void Control_CellClick(object sender, DataGridViewCellEventArgs args)
{
try
{
DoControl_CellClick(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Control_CellClick");
}
}
void DoControl_CellClick(DataGridViewCellEventArgs args)
{
EFPApp.ShowTempMessage(null);
CommandItems.PerformRefreshItems();
if (args.ColumnIndex < 0 || args.RowIndex < 0)
return;
EFPDataGridViewColumn Column = Columns[args.ColumnIndex];
if (Column.ColumnProducer == null)
return;
EFPDataViewRowInfo rowInfo = GetRowInfo(args.RowIndex);
Column.ColumnProducer.PerformCellClick(rowInfo, Column.Name);
FreeRowInfo(rowInfo);
}
#endregion
#region Раскрашивание ячеек
/*
* Проект
* ------
* Цветовые атрибуты ячеек для табличного просмотра и печати
*
* Назначение.
* Система свойств предназначена для перехвата и расширения возможностей
* события DataGridView.CellFormatting.
* - Единый стиль цветового оформления ячеек в зависимости от типа данных в
* ячейке (обычные данные, итого и подытоги, и т.д.) для всего приложения
* - Преобразование цветовых атрибутов в выделение при печати таблицы
* - Доступ к форматированию значения, т.к. станартное событи CellFormatting
* не позволяет получить доступ к отформатированному значению вне DataGridView
* и производных классов.
* - Дополнительные атрибуты группировки свойств при печати
*
* Чтобы использовать цветовые атрибуты, должен быть установлен один или оба обработчика
* события GetRowAttributes и GetCellAttributes.
* Эти события вызываются изнутри стандартного события DataGridView.CellFormatting.
* Событие GetRowAttributes вызывается один раз для всей строки, а
* GetCellAttributes - для каждой ячейки. GetRowAttributes вызывется перед
* GetCellAttributes. Значения, заданные в GetRowAttributes, копируются перед
* каждым вызовом GetCellAttributes.
* Оба события передают через аргумент Args следующие параметры
* RowIndex - номер строки в наборе данных. Это аргумент всегда больше или равен
* нулю, иначе событие не вызывается. Если требуется получить доступ к строке
* таблицы данных, можно использовать метод GetDataRow(), который вернет
* соответствующий объект DataRow.
* Свойство ColorType позволяет задать один из возможных типов оформления ячейки
* (обычный, специальный, итоговая строка или подытоги, заголовок)
* Свойство Grayed позволяет задать приглушенный цвет ячеек
*
* Событие GetRowAttributes, кроме общих, поддерживает следующие свойства:
* PrintWithPrevious - Логическое значение, которое при установке в true
* предотвращает при печати отрыв этой строки от предыдущей.
* PrintWithNext - аналогично PrintWithPrevious, но не отрывать от следующей.
* При наличии большого числа слепленных строк разрыв все равно будет выполнен,
* если все эти строки нельзя разместить на странице.
*
* Событие GetCellAttributes, кроме общих, поддерживает следующие свойства
* ColumnIndex - номер столбца. Метод GetColumn() обеспечивает доступ к объекту
* столбца, при необходимости.
* ValueEx, FormattingApplied - передаются непосредственно из CellFormatting
*/
#region Событие GetRowAttributes
/// <summary>
/// Событие вызывается перед рисованием строки и должно устанавливать общие атрибуты
/// для ячеек строки.
/// Если будет использоваться вывод сообщений об ошибках по строке, то должно быть установлено свойство
/// UserRowImages
/// </summary>
public event EFPDataGridViewRowAttributesEventHandler GetRowAttributes;
/// <summary>
/// Вызов события GetRowAttributes.
/// </summary>
/// <param name="args">Аргументы события</param>
protected virtual void OnGetRowAttributes(EFPDataGridViewRowAttributesEventArgs args)
{
if (GetRowAttributes != null)
GetRowAttributes(this, _GetRowAttributesArgs);
}
/// <summary>
/// Постоянно используем единственный объект аргумента для событий
/// </summary>
private EFPDataGridViewRowAttributesEventArgs _GetRowAttributesArgs;
/// <summary>
/// Общедоступный метод получения атрибутов строки
/// </summary>
/// <param name="rowIndex">Индекс строки</param>
/// <param name="reason"></param>
/// <returns>Атрибуты строки</returns>
public EFPDataGridViewRowAttributesEventArgs DoGetRowAttributes(int rowIndex, EFPDataGridViewAttributesReason reason)
{
_GetRowAttributesArgs.InitRow(rowIndex, reason);
OnGetRowAttributes(_GetRowAttributesArgs);
return _GetRowAttributesArgs;
}
#endregion
#region Событие GetCellAttributes
/// <summary>
/// Событие вызывается перед рисованием ячейки и должно выполнить форматирование
/// значения и установить цветовые атрибуты ячейки
/// </summary>
public event EFPDataGridViewCellAttributesEventHandler GetCellAttributes;
/// <summary>
/// Вызывает событие GetCellAttributes.
/// Этот метод вызывается только после предварительного вызова OnGetRowAttributes() (возможно,
/// несколько раз для разных столбцов), в котором указываются индекс строки и причина вызова.
/// </summary>
/// <param name="args">Аргументы события</param>
protected virtual void OnGetCellAttributes(EFPDataGridViewCellAttributesEventArgs args)
{
if (GetCellAttributes != null)
GetCellAttributes(this, _GetCellAttributesArgs);
}
private bool _Inside_OnGetCellAttributes; // 06.02.2018 - блокировка вложенного вызова
private void CallOnGetCellAttributes(int columnIndex, DataGridViewCellStyle cellStyle, bool styleIsTemplate, object originalValue)
{
if (_Inside_OnGetCellAttributes)
return;
_Inside_OnGetCellAttributes = true;
try
{
_GetCellAttributesArgs.InitCell(_GetRowAttributesArgs, columnIndex, cellStyle, styleIsTemplate, originalValue);
OnGetCellAttributes(_GetCellAttributesArgs);
}
finally
{
_Inside_OnGetCellAttributes = false;
}
}
private EFPDataGridViewCellAttributesEventArgs _GetCellAttributesArgs;
/// <summary>
/// Общедоступный метод получения атрибутов ячейки.
/// Перед вызовами метода должен идти один вызов DoGetRowAttributes() для строки
/// </summary>
/// <param name="_ColumnIndex">Номер столбца</param>
/// <returns>Атрибуты ячейки</returns>
public EFPDataGridViewCellAttributesEventArgs DoGetCellAttributes(int _ColumnIndex)
{
// // Избегаем делать строки Unshared
// DataGridViewRow Row = Control.RowList.SharedRow(GetRowAttributesArgs.RowIndex);
// DataGridViewCell Cell = Row.Cells[ColumnIndex];
// !!! Так не работает. Если строка Unshared, то ее RowIndex=-1 и свойство
// Cell вызывает ошибку при получении значения.
// 25.06.2021. Исследование исходников Net Framework.
// 1. DataGridView выполняет рисование строк во внутреннем методе методе PaintRows(), который получает "разделяемую" строку SharedRow().
// 2. Вызывается protected virtual метод DataGridViewRow.Paint().
// 3. Вызывается protected virtual метод DataGridViewRow.PaintCells().
// 4. Вызывается internal-метод DataGridViewCell.PaintWork(), ячейка относится к shared-строке.
// 5. Для получения значения вызывается DataGridViewCell.GetValue(). Он является protected virtual.
// Ему передается индекс строки, но реальный, а не (-1), как у SharedRow.
// Есть также internal-метод GetValueInternal(), он вызывается из DataGridView, но не нашел, как его вызвать косвенно.
// 6. Метод DataGridViewCell.GetValue() - весьма сложный. Он либо возвращает хранимое значение, либо вызывает
// DataGridView.OnCellValueNeeded(), либо обращается к связанному набору данных.
// В принципе, это можно повторить, но только если нет переопределения метода GetValue() в какой-нибудь ячейке нестандартного класса.
// Свойство DataGridViewCell.Value вызывает метод GetValue() передавая DataGridViewRow.Index в качестве номера строки.
// У SharedRow он равен (-1), что вызовет исключение.
// 7. Метод SharedRow() возвращает один и тот же объект DataGridViewRow(), если строка является Unshared. Его нельзя никак настроить,
// чтобы он мог вернуть значение ячейки.
// И почему нельзя было сделать метод DataGridViewCell.GetValue() общедоступным?
DataGridViewCell Cell = Control[_ColumnIndex, _GetRowAttributesArgs.RowIndex];
// 30.06.2021
// Если строкое значение получено из DataRow, которая была загружена из базы данных,
// то значение может содержать концевые пробелы
string sValue = Cell.Value as String;
if (sValue != null)
_GetCellAttributesArgs.Value = sValue.TrimEnd();
else
_GetCellAttributesArgs.Value = Cell.Value;
_GetCellAttributesArgs.FormattingApplied = false;
CallOnGetCellAttributes(_ColumnIndex, Cell.InheritedStyle, true, _GetCellAttributesArgs.Value);
if (_GetCellAttributesArgs.Reason == EFPDataGridViewAttributesReason.View ||
_GetCellAttributesArgs.Reason == EFPDataGridViewAttributesReason.Print) // 06.02.2018
{
_GetCellAttributesArgs.MoveTemplateToStyle();
// Убрано 25.06.2021.
// Непонятно, зачем было нужно. Было всегда (в 2008 году, в программе cs1, Modules\ClientAccDep\GridHandler.cs).
// Если значение возвращается из EFPGridProducerColumn, то не устанавливается свойство EFPDataGridViewCellAttributesEventArgs.FormattingApplied.
// Неприятность возникает после экспорта в Excel/Calc. Если для столбца задано форматирование с разделителем тысяч ("#,##0"), то
// в Excel попадает форматированное значение-строка, которое не преобразуется в число из-за пробелов.
//if (!_GetCellAttributesArgs.FormattingApplied)
// _GetCellAttributesArgs.Value = Cell.FormattedValue;
}
return _GetCellAttributesArgs;
}
#endregion
private bool _InsideRowPaint = false;
private bool _RowPrePaintErrorMessageWasShown = false;
void Control_RowPrePaint(object sender, DataGridViewRowPrePaintEventArgs args)
{
try
{
DoControl_RowPrePaint(args);
}
catch (Exception e)
{
if (!_RowPrePaintErrorMessageWasShown)
{
EFPApp.ShowException(e, "Control_RowPrePaint");
_RowPrePaintErrorMessageWasShown = true;
}
}
}
void DoControl_RowPrePaint(DataGridViewRowPrePaintEventArgs args)
{
if (!_InsideRowPaint)
{
_InsideRowPaint = true;
DoGetRowAttributes(args.RowIndex, EFPDataGridViewAttributesReason.View);
// 15.09.2015
// Для невиртуального табличного просмотра событие CellToolTipTextNeeded не вызывается.
// Соответственно, не появится всплывающая подсказка по ошибке для строки.
// Для такого просмотра устанавливаем ее в явном виде
if ((!Control.VirtualMode) && Control.DataSource == null && UseRowImages)
{
Control.Rows[args.RowIndex].HeaderCell.ToolTipText = _GetRowAttributesArgs.ToolTipText;
}
}
else
{
args.Graphics.FillRectangle(Brushes.Black, args.RowBounds);
args.Handled = true;
//System.Threading.Thread.Sleep(100);
}
}
void Control_RowPostPaint(object sender, DataGridViewRowPostPaintEventArgs args)
{
_InsideRowPaint = false;
}
private void Control_CellPainting(object sender, DataGridViewCellPaintingEventArgs args)
{
try
{
if (args.ColumnIndex == -1)
DoControl_RowHeaderCellPainting(args);
else if (args.RowIndex >= 0)
{
DataGridViewPaintParts pp = args.PaintParts;
if (args.CellStyle.ForeColor == Color.Transparent)
pp &= ~(DataGridViewPaintParts.ContentForeground|DataGridViewPaintParts.ContentBackground);
args.Paint(args.ClipBounds, pp);
if (_GetCellAttributesArgs.DiagonalUpBorder >= EFPDataGridViewBorderStyle.Thin)
args.Graphics.DrawLine(CreateBorderPen(args.CellStyle.ForeColor, _GetCellAttributesArgs.DiagonalUpBorder),
args.CellBounds.Left, args.CellBounds.Bottom - 1, args.CellBounds.Right - 1, args.CellBounds.Top);
if (_GetCellAttributesArgs.DiagonalDownBorder >= EFPDataGridViewBorderStyle.Thin)
args.Graphics.DrawLine(CreateBorderPen(args.CellStyle.ForeColor, _GetCellAttributesArgs.DiagonalDownBorder),
args.CellBounds.Left, args.CellBounds.Top, args.CellBounds.Right - 1, args.CellBounds.Bottom - 1);
args.Handled = true;
}
}
catch (Exception e)
{
if (!_RowPrePaintErrorMessageWasShown)
{
EFPApp.ShowException(e, "Control_CellPaint");
_RowPrePaintErrorMessageWasShown = true;
}
}
}
private static Pen CreateBorderPen(Color color, EFPDataGridViewBorderStyle borderStyle)
{
float w;
if (borderStyle == EFPDataGridViewBorderStyle.Thick)
w = 2;
else
w = 1;
return new Pen(color, w);
}
void Control_CellFormatting(object sender, DataGridViewCellFormattingEventArgs args)
{
if (args.RowIndex < 0)
return;
if (args.ColumnIndex < 0)
return;
try
{
// Если таблица получена из базы данных, то у строковых полей часто идут пробелы для заполнения по ширине поля.
// Если их не убрать, то значение "не влезет" в ячейку и будут символы "..." в правой части столбца
// 22.04.2021
// В отличие от предыдущей реализации, думаю, можно не выполнять лишние проверки.
// Вряд ли где-нибудь могут понадобиться концевые пробелы в строке.
string sValue = args.Value as String;
if (sValue != null)
args.Value = sValue.TrimEnd();
EFPDataGridViewColumn ColInfo = this.Columns[args.ColumnIndex];
// Форматирование значения и получение цветовых атрибутов
_GetCellAttributesArgs.Value = args.Value;
_GetCellAttributesArgs.FormattingApplied = args.FormattingApplied;
CallOnGetCellAttributes(args.ColumnIndex, args.CellStyle, false, args.Value);
args.Value = _GetCellAttributesArgs.Value;
args.FormattingApplied = _GetCellAttributesArgs.FormattingApplied;
// Установка цветов в просмотре
SetCellAttr(args.CellStyle, _GetCellAttributesArgs.ColorType, _GetCellAttributesArgs.Grayed, _GetCellAttributesArgs.ContentVisible);
if (GrayWhenDisabled && (!ControlEnabled))
{
// 18.07.2019
args.CellStyle.BackColor = SystemColors.ControlLight;
args.CellStyle.ForeColor = SystemColors.GrayText;
args.CellStyle.SelectionBackColor = SystemColors.ControlDark;
args.CellStyle.SelectionForeColor = SystemColors.ControlLight;
}
if (HideSelection && (!Control.Focused)/* 18.07.2019 */)
{
args.CellStyle.SelectionBackColor = args.CellStyle.BackColor;
args.CellStyle.SelectionForeColor = args.CellStyle.ForeColor;
}
// Отступ
if (_GetCellAttributesArgs.IndentLevel > 0)
{
Padding pd = args.CellStyle.Padding;
switch (args.CellStyle.Alignment)
{
case DataGridViewContentAlignment.TopLeft:
case DataGridViewContentAlignment.MiddleLeft:
case DataGridViewContentAlignment.BottomLeft:
pd.Left += (int)(Measures.CharWidthDots * 2 * _GetCellAttributesArgs.IndentLevel);
break;
case DataGridViewContentAlignment.TopRight:
case DataGridViewContentAlignment.MiddleRight:
case DataGridViewContentAlignment.BottomRight:
pd.Right += (int)(Measures.CharWidthDots * 2 * _GetCellAttributesArgs.IndentLevel);
break;
}
args.CellStyle.Padding = pd;
}
}
catch (Exception e)
{
LogoutTools.LogoutException(e, "Ошибка CellFormatting");
EFPApp.ShowTempMessage("Ошибка CellFormatting. " + e.Message);
}
}
#region Статические методы SetCellAttr
/// <summary>
/// Получить цвет фона и шрифта для заданных параметров ячейки.
/// Цвета помещаются в объект CellStyle
/// </summary>
/// <param name="cellStyle">Заполняемый объект</param>
/// <param name="colorType">Вариант цветного оформления ячейки</param>
public static void SetCellAttr(DataGridViewCellStyle cellStyle, EFPDataGridViewColorType colorType)
{
SetCellAttr(cellStyle, colorType, false, true);
}
/// <summary>
/// Получить цвет фона и шрифта для заданных параметров ячейки.
/// Цвета помещаются в объект CellStyle
/// </summary>
/// <param name="cellStyle">Заполняемый объект</param>
/// <param name="colorType">Вариант цветного оформления ячейки</param>
/// <param name="grayed">true -Выделение серым цветом</param>
public static void SetCellAttr(DataGridViewCellStyle cellStyle, EFPDataGridViewColorType colorType, bool grayed)
{
SetCellAttr(cellStyle, colorType, grayed, true);
}
/// <summary>
/// Получить цвет фона и шрифта для заданных параметров ячейки.
/// Цвета помещаются в объект CellStyle
/// </summary>
/// <param name="cellStyle">Заполняемый объект</param>
/// <param name="colorType">Вариант цветного оформления ячейки</param>
/// <param name="grayed">true -Выделение серым цветом</param>
/// <param name="contentVisible">true - должно ли быть видно содержимое ячейки.
/// Если false, то в <paramref name="cellStyle"/>.ForeColor помещается Color.Transparent</param>
public static void SetCellAttr(DataGridViewCellStyle cellStyle, EFPDataGridViewColorType colorType, bool grayed, bool contentVisible)
{
//if (ColorType == EFPDataGridViewColorType.Alter)
//{
// // !!! Нужно сделать исходя из текущего цвета ColorWindow
// CellStyle.BackColor = ColorEx.FromArgb(244,244,244);
//}
Color BackColor, ForeColor;
SetCellAttr(colorType, grayed, contentVisible, out BackColor, out ForeColor);
if (!BackColor.IsEmpty)
cellStyle.BackColor = BackColor;
if (!ForeColor.IsEmpty)
cellStyle.ForeColor = ForeColor;
}
/// <summary>
/// Получить цвет фона и шрифта для заданных параметров ячейки.
/// Статический метод, не привязанный к табличному просмотру и объекту DataGridViewCellStyle.
/// </summary>
/// <param name="colorType">Вариант цветного оформления ячейки</param>
/// <param name="grayed">true -Выделение серым цветом</param>
/// <param name="contentVisible">true - должно ли быть видно содержимое ячейки.
/// Если false, то в <paramref name="foreColor"/> помещается Color.Transparent</param>
/// <param name="backColor">Сюда помещается цвет фона, зависящий от <paramref name="colorType"/>.
/// Для ColorType.Normal записывается Color.Empty</param>
/// <param name="foreColor">Сюда помещается цвет текста, зависящий от <paramref name="colorType"/>,
/// <paramref name="grayed"/> и <paramref name="contentVisible"/>.</param>
public static void SetCellAttr(EFPDataGridViewColorType colorType, bool grayed, bool contentVisible, out Color backColor, out Color foreColor)
{
backColor = Color.Empty;
foreColor = Color.Empty;
switch (colorType)
{
case EFPDataGridViewColorType.Header:
backColor = EFPApp.Colors.GridHeaderBackColor;
foreColor = EFPApp.Colors.GridHeaderForeColor;
//CellStyle.Font.Style =FontStyle.Bold | FontStyle.Underline;
break;
case EFPDataGridViewColorType.Alter:
backColor = EFPApp.Colors.GridAlterBackColor;
break;
case EFPDataGridViewColorType.Special:
backColor = EFPApp.Colors.GridSpecialBackColor;
break;
case EFPDataGridViewColorType.Total1:
backColor = EFPApp.Colors.GridTotal1BackColor;
break;
case EFPDataGridViewColorType.Total2:
backColor = EFPApp.Colors.GridTotal2BackColor;
break;
case EFPDataGridViewColorType.TotalRow:
backColor = EFPApp.Colors.GridTotalRowBackColor;
foreColor = EFPApp.Colors.GridTotalRowForeColor;
break;
case EFPDataGridViewColorType.Error:
backColor = EFPApp.Colors.GridErrorBackColor;
foreColor = EFPApp.Colors.GridErrorForeColor;
break;
case EFPDataGridViewColorType.Warning:
backColor = EFPApp.Colors.GridWarningBackColor;
foreColor = EFPApp.Colors.GridWarningForeColor;
break;
}
if (grayed)
foreColor = Color.Gray;
if (!contentVisible)
foreColor = Color.Transparent;
}
#endregion
#region Атрибуты для Excel
/// <summary>
/// Получить атрибуты ячейки для передачи в Excel, соответствующие атрибутам ячейки табличного просмотра.
/// </summary>
/// <param name="cellAttr">Атрибуты ячейки ддя EFPDataGridView</param>
/// <returns>Атрибуnы ячейки для передачи в Excel</returns>
public static EFPDataGridViewExcelCellAttributes GetExcelCellAttr(EFPDataGridViewCellAttributesEventArgs cellAttr)
{
return GetExcelCellAttr(cellAttr.ColorType, cellAttr.Grayed);
}
/// <summary>
/// Получить атрибуты ячейки для передачи в Excel, соответствующие атрибутам ячейки табличного просмотра.
/// </summary>
/// <param name="colorType">Цвет ячейки</param>
/// <param name="grayed">true, если текст выделяется серым цветом</param>
/// <returns>Атрибуnы ячейки для передачи в Excel</returns>
public static EFPDataGridViewExcelCellAttributes GetExcelCellAttr(EFPDataGridViewColorType colorType, bool grayed)
{
EFPDataGridViewExcelCellAttributes Attr = new EFPDataGridViewExcelCellAttributes();
Attr.BackColor = Color.Empty;
Attr.ForeColor = Color.Empty;
switch (colorType)
{
case EFPDataGridViewColorType.Header:
Attr.ForeColor = Color.Navy;
Attr.BackColor = Color.White;
Attr.Bold = true;
//Attr.Underline = true;
Attr.Italic = true;
break;
case EFPDataGridViewColorType.Special:
Attr.BackColor = Color.FromArgb(255, 255, 204);
break;
case EFPDataGridViewColorType.Total1:
Attr.BackColor = Color.FromArgb(204, 255, 204);
Attr.Bold = true;
break;
case EFPDataGridViewColorType.Total2:
//Attr.BackColor = Color.FromArgb(255, 0, 255); // менее яркого нет
// 22.06.2016
Attr.BackColor = Color.FromArgb(0xFF, 0x99, 0xCC); // ColorIndex=38
Attr.Bold = true;
break;
case EFPDataGridViewColorType.TotalRow:
Attr.BackColor = Color.FromArgb(204, 204, 204);
Attr.Bold = true;
break;
case EFPDataGridViewColorType.Error:
Attr.BackColor = Color.Red;
Attr.Bold = true;
break;
case EFPDataGridViewColorType.Warning:
Attr.BackColor = Color.Yellow;
Attr.ForeColor = Color.Red;
Attr.Bold = true;
break;
case EFPDataGridViewColorType.Alter:
Attr.BackColor = Color.FromArgb(0xCC, 0xFF, 0xFF); // ColorIndex=34
break;
}
if (grayed)
Attr.ForeColor = Color.Gray;
return Attr;
}
#endregion
// Когда табличный просмотр не имеет фокуса ввода, выбранные строки подсвечиваются
// серым цветом, а не обычным цветом выделения
void Control_Enter(object sender, EventArgs args)
{
// if (!HideSelection)
Control.DefaultCellStyle.SelectionBackColor = SystemColors.Highlight;
}
void Control_Leave(object sender, EventArgs args)
{
// if (!HideSelection)
Control.DefaultCellStyle.SelectionBackColor = Color.DarkGray;
}
/// <summary>
/// Если true, то при утере просмотром фокуса ввода, подсветка выделенных
/// ячеек не выполняется (аналогично свойству у TextBox, TreeView и др.)
/// В отличие от этих управляющих элементов, значением по умолчанию
/// является false, то есть подсветка сохраняется
/// </summary>
public bool HideSelection
{
get { return _HideSelection; }
set
{
if (value == _HideSelection)
return;
_HideSelection = value;
//if (value)
// Grid.DefaultCellStyle.SelectionBackColor = Grid.DefaultCellStyle.BackColor;
//else
//{
// if (Grid.Focused)
// Control_Enter(null, null);
// else
// Control_Leave(null, null);
//}
Control.Invalidate();
}
}
private bool _HideSelection;
/// <summary>
/// Если установить в true, то заблокированный табличный просмотр (при Enabled=false) будет от ображаться серым цветом, как другие управляющие элементы.
/// По умолчанию - false, заблокированный табличный просмотр раскрашивается обычным образом
/// </summary>
public bool GrayWhenDisabled
{
get { return _GrayWhenDisabled; }
set
{
if (value == _GrayWhenDisabled)
return;
_GrayWhenDisabled = value;
if (!Enabled)
Control.Invalidate();
}
}
private bool _GrayWhenDisabled;
#endregion
#region Картинки в заголовках строк и всплывающие подсказки
/// <summary>
/// Возвращает имя изображения в списке EFPApp.MainImages, соответствующее EFPDataGridViewImageKind.
/// Для <paramref name="imageKind"/>=None возвращает "EmptyImage".
/// </summary>
/// <param name="imageKind">Вариант изображения</param>
/// <returns>Имя изображения</returns>
public static string GetImageKey(EFPDataGridViewImageKind imageKind)
{
return GetImageKey(imageKind, "EmptyImage");
}
/// <summary>
/// Возвращает имя изображения в списке EFPApp.MainImages, соответствующее EFPDataGridViewImageKind.
/// </summary>
/// <param name="imageKind">Вариант изображения</param>
/// <param name="noneImageKey">Имя изображения для <paramref name="imageKind"/>=None</param>
/// <returns>Имя изображения</returns>
public static string GetImageKey(EFPDataGridViewImageKind imageKind, string noneImageKey)
{
switch (imageKind)
{
case EFPDataGridViewImageKind.Error: return "Error";
case EFPDataGridViewImageKind.Warning: return "Warning";
case EFPDataGridViewImageKind.Information: return "Information";
case EFPDataGridViewImageKind.None: return noneImageKey;
default: return "UnknownState";
}
}
/// <summary>
/// Разрешить рисование изображений в заголовках строк и вывод всплывающих
/// подсказок. При установленном свойстве не будут правильно отображаться
/// значки и подсказки об ошибках в строках с помощью DataRow.RowError.
/// По умолчанию - false (можно использовать стандартный механизм индикации в
/// DataGridView).
/// </summary>
[DefaultValue(false)]
public bool UseRowImages
{
get { return _UseRowImages; }
set
{
if (value == _UseRowImages)
return;
_UseRowImages = value;
if (value)
Control.ShowRowErrors = false;
if (Control.Visible && ProviderState == EFPControlProviderState.Attached)
Control.InvalidateColumn(-1);
}
}
private bool _UseRowImages;
/// <summary>
/// Использовать свойство DataRow.RowError для отображения признака ошибки в
/// заголовке строки и подсказки, как это по умолчанию делеает DataGridView.
/// Свойство имеет значение при установленном UseRowImages.
/// По умолчанию - false (предполагается, что признак ошибки строки
/// устанавливается обработчиком GetRowAttributes)
/// Установка свойства не препятствует реализации GetRowAttributes
/// </summary>
[DefaultValue(false)]
public bool UseRowImagesDataError
{
get { return _UseRowImagesDataError; }
set
{
if (value == _UseRowImagesDataError)
return;
_UseRowImagesDataError = value;
if (Control.Visible && ProviderState == EFPControlProviderState.Attached)
Control.InvalidateColumn(-1);
}
}
private bool _UseRowImagesDataError;
/// <summary>
/// Изображение, которое следует вывести в верхней левой ячейке просмотра
/// Произвольное изображение может быть задано с помощью свойства TopLeftCellUserImage
/// Свойство UseRowImages должно быть установлено
/// </summary>
[DefaultValue(EFPDataGridViewImageKind.None)]
public EFPDataGridViewImageKind TopLeftCellImageKind
{
get { return _TopLeftCellImageKind; }
set
{
if (value == _TopLeftCellImageKind)
return;
_TopLeftCellImageKind = value;
if (Control.Visible && ProviderState == EFPControlProviderState.Attached)
Control.InvalidateCell(-1, -1);
}
}
private EFPDataGridViewImageKind _TopLeftCellImageKind;
/// <summary>
/// Произвольное изображение, которое следует вывести в верхней левой ячейке
/// просмотра
/// Свойство UseRowImages должно быть установлено
/// </summary>
[DefaultValue(null)]
public Image TopLeftCellUserImage
{
get { return _TopLeftCellUserImage; }
set
{
if (value == _TopLeftCellUserImage)
return;
_TopLeftCellUserImage = value;
if (Control.Visible && ProviderState == EFPControlProviderState.Attached)
Control.InvalidateCell(-1, -1);
}
}
private Image _TopLeftCellUserImage;
/// <summary>
/// Текст всплывающей подсказки, выводимой при наведении курсора мыши на
/// верхнюю левую ячейку просмотра.
/// Свойство инициализируется автоматически, если UseRowImages установлено в true.
/// Свойство не включает в себя текст, генерируемый ShowRowCountInTopLeftCellToolTipText
/// </summary>
public string TopLeftCellToolTipText
{
get { return Control.TopLeftHeaderCell.ToolTipText; }
set
{
_TopLeftCellToolTipText = value;
// Обновляем, даже если подсказка не изменилась
string s = String.Empty;
if (value != null)
s = value;
if (ShowRowCountInTopLeftCellToolTipText && Control.DataSource != null)
{
if (s.Length > 0)
s += Environment.NewLine;
s += "Строк в просмотре: " + Control.RowCount.ToString();
}
Control.TopLeftHeaderCell.ToolTipText = s;
}
}
private string _TopLeftCellToolTipText;
/// <summary>
/// Необходимость обновить подсказку по таймеру
/// </summary>
private bool _TopLeftCellToolTipTextUpdateFlag = false;
/// <summary>
/// Если свойство установить в true, то в верхней левой ячейке будет отображаться всплывающая
/// подсказка "Записей в просмотре: XXX".
/// Свойство подключает обработку события DataGridView.DataBindingComplete. Не работает, если табличный
/// просмотр не присоединен к источнику данных.
/// По умолчанию - false - свойство отключено.
/// </summary>
public bool ShowRowCountInTopLeftCellToolTipText
{
get { return _ShowRowCountInTopLeftCellToolTipText; }
set
{
if (value == _ShowRowCountInTopLeftCellToolTipText)
return;
_ShowRowCountInTopLeftCellToolTipText = value;
TopLeftCellToolTipText = _TopLeftCellToolTipText; // обновляем подсказку
}
}
private bool _ShowRowCountInTopLeftCellToolTipText;
private void DoControl_RowHeaderCellPainting(DataGridViewCellPaintingEventArgs args)
{
if (!_UseRowImages)
return;
try
{
if (args.RowIndex < 0)
DoControl_RowHeaderCellPainting(args, _TopLeftCellImageKind, _TopLeftCellUserImage);
else
DoControl_RowHeaderCellPainting(args, _GetRowAttributesArgs.ImageKind, _GetRowAttributesArgs.UserImage);
}
catch
{
DoControl_RowHeaderCellPainting(args, EFPDataGridViewImageKind.Error, null);
}
}
private void DoControl_RowHeaderCellPainting(DataGridViewCellPaintingEventArgs args, EFPDataGridViewImageKind imageKind, Image userImage)
{
args.PaintBackground(args.ClipBounds, false);
args.PaintContent(args.ClipBounds);
if (userImage == null && imageKind != EFPDataGridViewImageKind.None)
userImage = EFPApp.MainImages.Images[GetImageKey(imageKind, String.Empty)];
if (userImage != null)
{
Rectangle r = args.CellBounds;
Point pt = r.Location;
pt.X += r.Width / 2 + 3;
pt.Y += (r.Height - userImage.Height) / 2;
args.Graphics.DrawImage(userImage, pt);
}
args.Handled = true;
}
/// <summary>
/// Получить текст подсказки для заголовка строки
/// </summary>
/// <param name="rowIndex">Индекс строки или (-1) для верхней левой ячейки</param>
/// <returns>Текст всплывающей подсказки, получаемый с помощью события
/// GetRowAttributes или значениек свойства TopLeftCellToolTpText</returns>
public string GetRowToolTipText(int rowIndex)
{
if (rowIndex < 0)
return TopLeftCellToolTipText;
else
return DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.ToolTip).ToolTipText;
}
/// <summary>
/// Получить текст подсказки для ячейки
/// </summary>
/// <param name="rowIndex"></param>
/// <param name="columnIndex"></param>
/// <returns></returns>
public string GetCellToolTipText(int rowIndex, int columnIndex)
{
if (columnIndex < 0)
return GetRowToolTipText(rowIndex); // для заголовка столбка
if (rowIndex < 0)
return Control.Columns[columnIndex].ToolTipText; // для заголовка столбца
EFPDataGridViewColumn col = Columns[columnIndex];
string sText = String.Empty;
// Нужна ли подсказка по содержимому ячейки?
bool CurrentCellToolTip = true;
if (CurrentConfig != null)
CurrentCellToolTip = CurrentConfig.CurrentCellToolTip;
if (CurrentCellToolTip)
{
// 1. Подсказка по текущему значению ячейки
if (col.GridColumn is DataGridViewTextBoxColumn)
sText = GetCellTextValue(rowIndex, columnIndex);
else if (col.GridColumn is DataGridViewCheckBoxColumn)
{
object v = Control.Rows[rowIndex].Cells[columnIndex].Value;
if (DataTools.GetBool(v))
sText = "Да";
else
sText = "Нет";
}
else
sText = String.Empty;
// 2. Подсказка, добавляемая обработчиком столбца
col.CallCellToolTextNeeded(rowIndex, ref sText);
if (!String.IsNullOrEmpty(sText))
{
string sHead = col.GridColumn.ToolTipText;
if (String.IsNullOrEmpty(sHead))
{
sHead = col.GridColumn.HeaderText;
if (String.IsNullOrEmpty(sHead))
sHead = "Столбец без названия";
}
sText = sHead + ": " + sText;
}
}
// 3. Пользовательский обработчик
DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.ToolTip);
_GetCellAttributesArgs.ToolTipText = sText;
DoGetCellAttributes(columnIndex);
if (_GetCellAttributesArgs.ContentVisible || _GetCellAttributesArgs.ToolTipTextHasBeenSet)
return _GetCellAttributesArgs.ToolTipText;
else
return String.Empty; // 12.01.2022
}
/// <summary>
/// Нужно ли для данной строки получать подсказку с помощью EFPGridProducer?
/// Непереопределенный метод возвращает true.
/// </summary>
/// <param name="rowIndex">Индекс строки табличного просмотра</param>
/// <returns>Признак использования</returns>
protected virtual bool GetGridProducerToolTipRequired(int rowIndex)
{
return true;
}
private void Control_CellToolTipTextNeeded(object sender, DataGridViewCellToolTipTextNeededEventArgs args)
{
if (args.RowIndex < 0) // Подсказка для верхней левой ячейки задана свойством TopLeftCellToolTipText
return; // Если еще раз к нему обратиться, то будет Stack overflow
try
{
if (args.ColumnIndex < 0)
args.ToolTipText = GetRowToolTipText(args.RowIndex);
else
args.ToolTipText = GetCellToolTipText(args.RowIndex, args.ColumnIndex);
}
catch (Exception e)
{
args.ToolTipText = "!!! Ошибка при получении подсказки !!!" + Environment.NewLine + e.Message;
}
}
/// <summary>
/// Перейти к следующей иди предыдущей строке с ошибкой
/// </summary>
/// <param name="fromTableBegin">true - перейти к первой или последней строке в таблице с подходящим условием,
/// false - перейти к следующей или предыдущей относительно текущей строки</param>
/// <param name="forward">true - перейти вперед (в сторону конца таблицы), false - назад (к началу)</param>
/// <param name="imageKind">Какую строку найти (условие поиска)</param>
public void GotoNextErrorRow(bool fromTableBegin, bool forward, EFPDataGridViewImageKind imageKind)
{
if (!UseRowImages)
{
EFPApp.ShowTempMessage("Просмотр не поддерживает навигацию по строкам с ошибками");
return;
}
if (Control.RowCount == 0)
{
EFPApp.ShowTempMessage("Просмотр не содержит ни одной строки");
}
int StartRowIndex;
if (fromTableBegin)
StartRowIndex = -1;
else
StartRowIndex = CurrentRowIndex;
int NewRowIndex = FindErrorRow(StartRowIndex, forward, imageKind);
if (NewRowIndex < 0)
{
string msg;
switch (imageKind)
{
case EFPDataGridViewImageKind.Error:
msg = " с ошибкой";
break;
case EFPDataGridViewImageKind.Warning:
msg = " с ошибкой или предупреждением";
break;
case EFPDataGridViewImageKind.Information:
msg = " с сообщением";
break;
case EFPDataGridViewImageKind.None:
msg = " без ошибок";
break;
default:
msg = ", удовлетворяющая условию,";
break;
}
EFPApp.ShowTempMessage((forward ? "Достигнут конец таблицы" : "Достигнуто начало таблицы") +
", но строка" + msg + " не найдена");
return;
}
CurrentRowIndex = NewRowIndex;
}
/// <summary>
/// Найти строку, содержащую признак ошибки
/// </summary>
/// <param name="startRowIndex">С какой строки начать поиск. Значение (-1) указывает на поиск с начала (с конца) таблицы</param>
/// <param name="forward">true-искать вперед к концу таблицы, false - искать назад к началу таблицы</param>
/// <param name="imageKind">Какую строку найти (условие поиска)</param>
/// <returns>Индекс найденной строки или (-1), если строка не найдена</returns>
public int FindErrorRow(int startRowIndex, bool forward, EFPDataGridViewImageKind imageKind)
{
if (forward)
{
if (startRowIndex < 0)
{
for (int i = 0; i < Control.RowCount; i++)
{
if (TestRowImageKind(i, imageKind))
return i;
}
}
else
{
for (int i = startRowIndex + 1; i < Control.RowCount; i++)
{
if (TestRowImageKind(i, imageKind))
return i;
}
}
}
else
{
if (startRowIndex < 0)
{
for (int i = Control.RowCount - 1; i >= 0; i--)
{
if (TestRowImageKind(i, imageKind))
return i;
}
}
else
{
for (int i = startRowIndex - 1; i >= 0; i--)
{
if (TestRowImageKind(i, imageKind))
return i;
}
}
}
// Строка не найдена
return -1;
}
private bool TestRowImageKind(int rowIndex, EFPDataGridViewImageKind imageKind)
{
EFPDataGridViewImageKind ThisKind = GetRowImageKind(rowIndex);
switch (imageKind)
{
case EFPDataGridViewImageKind.None:
return ThisKind == EFPDataGridViewImageKind.None;
case EFPDataGridViewImageKind.Information:
return ThisKind != EFPDataGridViewImageKind.None;
case EFPDataGridViewImageKind.Warning:
return ThisKind == EFPDataGridViewImageKind.Warning || ThisKind == EFPDataGridViewImageKind.Error;
case EFPDataGridViewImageKind.Error:
return ThisKind == EFPDataGridViewImageKind.Error;
default:
throw new ArgumentException("Недопустимый тип изображения строки для поиска:" + imageKind.ToString(), "imageKind");
}
}
/// <summary>
/// Получить тип изображения для строки
/// </summary>
/// <param name="rowIndex">Индекс строки в просмотре.
/// Если равно (-1), возвращается значение свойства TopLeftCellImageKind.
/// Иначе генерируется событие GetRowAttributes для получения значка строки</param>
/// <returns></returns>
public EFPDataGridViewImageKind GetRowImageKind(int rowIndex)
{
if (rowIndex < 0)
return TopLeftCellImageKind;
else
return DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.View).ImageKind;
}
/// <summary>
/// Имя текстового столбца в связанном наборе данных, используемое для идентификации строки при выводе сообщений об ошибках для группы строк
/// </summary>
public string RowIdTextDataColumnName { get { return _RowIdTextDataColumnName; } set { _RowIdTextDataColumnName = value; } }
private string _RowIdTextDataColumnName;
/// <summary>
/// Добавить в список ErrorMessages сообщения, относящиеся к строке с заданным
/// индексом.
/// </summary>
/// <param name="errorMessages">Список для добавления сообщений</param>
/// <param name="rowIndex">Индекс строки просмотра</param>
public void GetRowErrorMessages(ErrorMessageList errorMessages, int rowIndex)
{
GetRowErrorMessages(errorMessages, rowIndex, false);
}
/// <summary>
/// Добавить в список ErrorMessages сообщения, относящиеся к строке с заданным
/// индексом.
/// </summary>
/// <param name="errorMessages">Список для добавления сообщений</param>
/// <param name="rowIndex">Индекс строки просмотра</param>
/// <param name="useRowIdText">Если true, то перед сообщениями будет добавлен текст с идентификатором строки</param>
public void GetRowErrorMessages(ErrorMessageList errorMessages, int rowIndex, bool useRowIdText)
{
#if DEBUG
if (errorMessages == null)
throw new ArgumentNullException("errorMessages");
#endif
_GetRowAttributesArgs.RowErrorMessages = errorMessages;
try
{
DoGetRowErrorMessages(rowIndex, useRowIdText);
}
finally
{
_GetRowAttributesArgs.RowErrorMessages = null;
}
}
private void DoGetRowErrorMessages(int rowIndex, bool useRowIdText)
{
int cnt = _GetRowAttributesArgs.RowErrorMessages.Count;
DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.ToolTip);
if (_GetRowAttributesArgs.ImageKind != EFPDataGridViewImageKind.None &&
cnt == _GetRowAttributesArgs.RowErrorMessages.Count)
{
// Признак ошибки установлен, но сообщение не добавлено
string Msg;
if (String.IsNullOrEmpty(_GetRowAttributesArgs.ToolTipText))
Msg = "Сообщение об ошибке отсутствует";
else
Msg = _GetRowAttributesArgs.ToolTipText.Replace(Environment.NewLine, " ");
ErrorMessageKind Kind2;
switch (_GetRowAttributesArgs.ImageKind)
{
case EFPDataGridViewImageKind.Error: Kind2 = ErrorMessageKind.Error; break;
case EFPDataGridViewImageKind.Warning: Kind2 = ErrorMessageKind.Warning; break;
default: Kind2 = ErrorMessageKind.Info; break;
}
_GetRowAttributesArgs.RowErrorMessages.Add(new ErrorMessageItem(Kind2, Msg, null, rowIndex));
}
if (useRowIdText && (_GetRowAttributesArgs.RowErrorMessages.Count > cnt))
_GetRowAttributesArgs.RowErrorMessages.SetPrefix(_GetRowAttributesArgs.RowIdText + " - ", cnt);
}
/// <summary>
/// Получить список сообщений для выбранных строк в просмотре
/// </summary>
/// <param name="errorMessages">Список, куда будут добавлены сообщения</param>
/// <param name="useRowIdText">true - добавить перед сообщениями номера строк</param>
public void GetSelectedRowsErrorMessages(ErrorMessageList errorMessages, bool useRowIdText)
{
if (errorMessages == null)
throw new ArgumentNullException("errorMessages");
int[] RowIdxs = SelectedRowIndices;
_GetRowAttributesArgs.RowErrorMessages = errorMessages;
try
{
for (int i = 0; i < RowIdxs.Length; i++)
DoGetRowErrorMessages(RowIdxs[i], useRowIdText);
}
finally
{
_GetRowAttributesArgs.RowErrorMessages = null;
}
}
/// <summary>
/// Получить список сообщений для выбранных строк в просмотре
/// Текст, идентифицирующий строку, задается, если число выбранных строк больше 1
/// </summary>
/// <param name="errorMessages">Список, куда будут добавлены сообщения</param>
public void GetSelectedRowsErrorMessages(ErrorMessageList errorMessages)
{
if (errorMessages == null)
throw new ArgumentNullException("errorMessages");
int[] RowIdxs = SelectedRowIndices;
_GetRowAttributesArgs.RowErrorMessages = errorMessages;
try
{
for (int i = 0; i < RowIdxs.Length; i++)
DoGetRowErrorMessages(RowIdxs[i], RowIdxs.Length > 1);
}
finally
{
_GetRowAttributesArgs.RowErrorMessages = null;
}
}
/// <summary>
/// Получить список сообщений для всех строк в просмотре.
/// Перед сообщениями добавляется текст, идентифицирующий строку
/// </summary>
/// <param name="errorMessages"></param>
public void GetAllRowsErrorMessages(ErrorMessageList errorMessages)
{
if (errorMessages == null)
throw new ArgumentNullException("errorMessages");
_GetRowAttributesArgs.RowErrorMessages = errorMessages;
try
{
for (int i = 0; i < Control.RowCount; i++)
DoGetRowErrorMessages(i, true);
}
finally
{
_GetRowAttributesArgs.RowErrorMessages = null;
}
}
/// <summary>
/// Инициализировать значок и всплывающую подсказку для верхней левой ячейки
/// табличного просмотра, где будет выведено количество ошибок и предупреждений
/// Устанавливает свойства TopLeftCellImageKind и TopLeftCellToolTipText
/// При вызове метода перебираются все строки табличного просмотра. Для каждой
/// строки вызывается метод GetRowImageKind(), который, в свою очередь, вызывает
/// для строки событие GetRowAttributes.
/// Строки с состоянием Information не учитываются и значок (i) в верхней левой
/// ячейке не выводится.
/// Метод ничего не делает при UseRowImages=false.
/// </summary>
public void InitTopLeftCellTotalInfo()
{
if (!UseRowImages)
return;
int ErrorCount = 0;
int WarningCount = 0;
int n = Control.RowCount;
if (n == 0)
{
if (SourceAsDataView != null)
n = SourceAsDataView.Count;
}
for (int i = 0; i < n; i++)
{
switch (GetRowImageKind(i))
{
case EFPDataGridViewImageKind.Error:
ErrorCount++;
break;
case EFPDataGridViewImageKind.Warning:
WarningCount++;
break;
}
}
if (ErrorCount == 0 && WarningCount == 0)
TopLeftCellToolTipText = "Нет строк с ошибками или предупреждениями";
else
{
StringBuilder sb = new StringBuilder();
if (ErrorCount > 0)
{
sb.Append("Есть строки с ошибками (");
sb.Append(ErrorCount);
sb.Append(")");
sb.Append(Environment.NewLine);
}
if (WarningCount > 0)
{
sb.Append("Есть строки с предупреждениями (");
sb.Append(WarningCount);
sb.Append(")");
sb.Append(Environment.NewLine);
}
sb.Append("Используйте Ctrl+] и Ctrl+[ для перехода к этим строкам");
TopLeftCellToolTipText = sb.ToString();
}
if (ErrorCount > 0)
TopLeftCellImageKind = EFPDataGridViewImageKind.Error;
else
{
if (WarningCount > 0)
TopLeftCellImageKind = EFPDataGridViewImageKind.Warning;
else
TopLeftCellImageKind = EFPDataGridViewImageKind.None;
}
}
/// <summary>
/// Перебирает все строки просмотра и возвращает максимальное значение типа
/// ошибки для строки
/// </summary>
/// <returns>Тип значка.</returns>
public EFPDataGridViewImageKind GetAllRowsImageKind()
{
int n = Control.RowCount;
if (n == 0)
{
if (SourceAsDataView != null)
n = SourceAsDataView.Count;
}
EFPDataGridViewImageKind MaxLevel = EFPDataGridViewImageKind.None;
for (int i = 0; i < n; i++)
{
EFPDataGridViewImageKind ThisLevel = GetRowImageKind(i);
if (ThisLevel > MaxLevel)
{
MaxLevel = ThisLevel;
if (MaxLevel == EFPDataGridViewImageKind.Error)
break;
}
}
return MaxLevel;
}
#endregion
#region Быстрый поиск по первым буквам
/// <summary>
/// Возвращает true, если хотя бы один столбец поддерживает поиск по буквам
/// </summary>
public bool CanIncSearch
{
get
{
for (int i = 0; i < Columns.Count; i++)
{
if (Columns[i].CanIncSearch)
return true;
}
return false;
}
}
/// <summary>
/// Текущий столбец, в котором осуществляется поиск по первым буквам.
/// Установка свойства в значение, отличное от null начинает поиск.
/// Установка в null завершает поиск по буквам
/// </summary>
public EFPDataGridViewColumn CurrentIncSearchColumn
{
get
{
return _CurrentIncSearchColumn;
}
set
{
if (value == _CurrentIncSearchColumn)
return;
_CurrentIncSearchColumn = value;
_CurrentIncSearchChars = String.Empty;
// FCurrentIncSearchMask = null;
// Некорректно работает при нажатии Backspace (норовит съесть лишнее)
// Как разрешить ввод разделителей (SkipLiterals не работает?)
//if (value!=null)
//{
// if (value.Mask != null)
// {
// string EditMask = value.Mask.EditMask;
// if (!String.IsNullOrEmpty(EditMask))
// {
// FCurrentIncSearchMask = new MaskedTextProvider(EditMask);
// FCurrentIncSearchMask.SkipLiterals = true;
// }
// }
//}
IncSearchDataView = null; // сброс DataView
if (value != null && TextSearchContext != null)
TextSearchContext.ResetContinueEnabled();
if (CommandItems != null)
CommandItems.RefreshIncSearchItems();
}
}
private EFPDataGridViewColumn _CurrentIncSearchColumn;
//private void ResetCurrentIncSearchColumn(object sender, EventArgs args)
//{
// CurrentIncSearchColumn = null;
//}
/// <summary>
/// Текущие набранные символы для быстрого поиска
/// </summary>
public string CurrentIncSearchChars
{
get { return _CurrentIncSearchChars; }
internal set { _CurrentIncSearchChars = value; }
}
private string _CurrentIncSearchChars;
/// <summary>
/// Провайдер маски для поиска по первым буквам
/// </summary>
//private MaskedTextProvider FCurrentIncSearchMask;
private MaskedTextProvider GetIncSearchMaskProvider()
{
if (_CurrentIncSearchColumn == null)
return null;
if (_CurrentIncSearchColumn.MaskProvider == null)
return null;
string EditMask = _CurrentIncSearchColumn.MaskProvider.EditMask;
if (String.IsNullOrEmpty(EditMask))
return null;
MaskedTextProvider Provider = new MaskedTextProvider(EditMask,
// System.Globalization.CultureInfo.CurrentCulture,
_CurrentIncSearchColumn.MaskProvider.Culture, // 04.06.2019
false, (char)0, (char)0, false);
Provider.SkipLiterals = true;
Provider.ResetOnSpace = false;
Provider.Set(_CurrentIncSearchChars);
return Provider;
}
void Control_KeyPress(object sender, KeyPressEventArgs args)
{
try
{
DoControl_KeyPress(args);
}
catch (Exception e)
{
EFPApp.ShowException(e, "Ошибка обработки нажатия клавиши KeyPress");
}
}
void DoControl_KeyPress(KeyPressEventArgs args)
{
if (args.Handled)
return;
if (args.KeyChar < ' ')
return;
if (args.KeyChar == ' ' && System.Windows.Forms.Control.ModifierKeys != Keys.None)
return; // 31.10.2018 Отсекаем Shift-Space, Ctrl-Space и прочее, так как эти клавиши обрабатываются не как символы для поиска
// Нажатие клавиши может начать поиск по первым буквам
if (CurrentIncSearchColumn == null)
{
// Если поиск не начат, пытаемся его начать
if (CurrentColumn == null)
return;
if (!CurrentColumn.CanIncSearch)
return;
CurrentIncSearchColumn = CurrentColumn;
}
args.Handled = true;
EFPApp.ShowTempMessage(null);
// Под Windows-98 неправильная кодировка русских букв - исправляем
char KeyChar = WinFormsTools.CorrectCharWin98(args.KeyChar);
MaskedTextProvider MaskProvider = GetIncSearchMaskProvider();
string s;
if (MaskProvider != null)
{
// для столбца задана маска
if (!AddCharToIncSearchMask(MaskProvider, KeyChar, out s))
return;
}
else
{
// Нет маски
s = (CurrentIncSearchChars + KeyChar);
}
bool Res;
EFPApp.BeginWait("Поиск");
try
{
//Res = CurrentColumn.PerformIncSearch(s.ToUpper(), false);
// 27.12.2020
Res = CurrentIncSearchColumn.PerformIncSearch(s.ToUpper(), false);
}
finally
{
EFPApp.EndWait();
}
if (!Res)
{
EFPApp.ShowTempMessage("Символ \"" + KeyChar + "\" не может быть добавлен к строке быстрого поиска");
return;
}
_CurrentIncSearchChars = s;
if (CommandItems != null)
CommandItems.RefreshIncSearchItems();
}
private bool AddCharToIncSearchMask(MaskedTextProvider maskProvider, char keyChar, out string s)
{
s = null;
string s1 = new string(keyChar, 1);
s1 = s1.ToUpper();
keyChar = s1[0];
int ResPos;
MaskedTextResultHint ResHint;
if (!maskProvider.Add(keyChar, out ResPos, out ResHint))
{
// Пытаемся подобрать символ в нижнем регистре
s1 = s1.ToLower();
char KeyChar2 = s1[0];
if (!maskProvider.Add(KeyChar2, out ResPos, out ResHint))
{
// MaskedTextProvider почему-то не пропускает символы-разделители в
// качестве ввода, независимо от SkipLiterals
// Поэтому, если следующим символом ожидается разделитель, то его
// добавляем к строке поиска вручную
if (ResHint != MaskedTextResultHint.UnavailableEditPosition)
{
if ((!maskProvider.IsEditPosition(maskProvider.LastAssignedPosition + 1)) && maskProvider[maskProvider.LastAssignedPosition + 1] == keyChar)
{
s = maskProvider.ToString(0, maskProvider.LastAssignedPosition + 1) + keyChar;
return true;
}
}
EFPApp.ShowTempMessage("Нельзя добавить символ \"" + keyChar + "\" для быстрого поиска. " + GetMaskedTextResultHintText(ResHint));
return false;
}
}
if (ResHint == MaskedTextResultHint.CharacterEscaped)
{
EFPApp.ShowTempMessage("Нельзя добавить символ \"" + keyChar + "\" для быстрого поиска. " + GetMaskedTextResultHintText(ResHint));
return false;
}
s = maskProvider.ToString(0, maskProvider.LastAssignedPosition + 1);
return true;
}
private static string GetMaskedTextResultHintText(MaskedTextResultHint resHint)
{
switch (resHint)
{
case MaskedTextResultHint.DigitExpected:
return "Ожидалась цифра";
case MaskedTextResultHint.AlphanumericCharacterExpected:
return "Ожидалась цифра или буква";
case MaskedTextResultHint.LetterExpected:
return "Ожидалась буква";
case MaskedTextResultHint.UnavailableEditPosition:
return "Все символы уже введены";
case MaskedTextResultHint.CharacterEscaped:
return "Символ пропускается";
default:
return resHint.ToString();
}
}
void DoControl_KeyDown2(KeyEventArgs args)
{
if (args.Handled)
return; // уже обработано
if (Control.IsCurrentCellInEditMode)
return; // в режиме редактирования ячейки не обрабатывается
if (CurrentIncSearchColumn != null)
{
if (args.KeyCode == Keys.Back)
{
args.Handled = true;
EFPApp.ShowTempMessage(null);
if (_CurrentIncSearchChars.Length < 1)
{
EFPApp.ShowTempMessage("Строка быстрого поиска не содержит введенных символов");
return;
}
MaskedTextProvider MaskProvider = GetIncSearchMaskProvider();
string s;
if (MaskProvider != null)
{
if (_CurrentIncSearchChars.Length == MaskProvider.LastAssignedPosition + 1)
{
MaskProvider.Remove();
s = MaskProvider.ToString(0, MaskProvider.LastAssignedPosition + 1);
}
else
// Последний символ в строке поиска - разделитель, введенный вручную
s = _CurrentIncSearchChars.Substring(0, _CurrentIncSearchChars.Length - 1);
}
else
s = _CurrentIncSearchChars.Substring(0, _CurrentIncSearchChars.Length - 1);
_CurrentIncSearchChars = s;
//CurrentColumn.PerformIncSearch(s.ToUpper(), false);
// 27.12.2020
CurrentIncSearchColumn.PerformIncSearch(s.ToUpper(), false);
if (CommandItems != null)
CommandItems.RefreshIncSearchItems();
}
}
#if XXXXX
// Обработка сочетаний для буфера обмена
if (Args.Modifiers == Keys.Control)
{
switch (Args.KeyCode)
{
case Keys.X:
if ((CommandItems.ciCut.Usage & EFPCommandItemUsage.ShortCut) == EFPCommandItemUsage.ShortCut)
CommandItems.ciCut.PerformClick();
Args.Handled = true;
break;
case Keys.C:
case Keys.Insert:
if ((CommandItems.ciCopy.Usage & EFPCommandItemUsage.ShortCut) == EFPCommandItemUsage.ShortCut)
CommandItems.ciCopy.PerformClick();
Args.Handled = true;
break;
case Keys.V:
if (CommandItems.PasteHandler.Count > 0)
CommandItems.PasteHandler.PerformPaste(EFPPasteReason.Paste);
Args.Handled = true;
break;
}
}
if (Args.Modifiers == Keys.Shift)
{
switch (Args.KeyCode)
{
case Keys.Delete:
if ((CommandItems.ciCut.Usage & EFPCommandItemUsage.ShortCut) == EFPCommandItemUsage.ShortCut)
CommandItems.ciCut.PerformClick();
Args.Handled = true;
break;
case Keys.Insert:
if (CommandItems.PasteHandler.Count > 0)
CommandItems.PasteHandler.PerformPaste(EFPPasteReason.Paste);
Args.Handled = true;
break;
}
}
#endif
}
/// <summary>
/// Вспомогательный объект для выполнения поиска
/// </summary>
internal DataView IncSearchDataView;
/// <summary>
/// Признак того, что IncSearchDataView ссылается на созданную вручную таблицу,
/// а не на исходные данные просмотра. Свойство устанавливается в момент
/// инициализации IncSearchDataView
/// </summary>
internal bool IncSearchDataViewIsManual;
/// <summary>
/// Получить индекс первого столбца с установленным CanIncSearch или (-1), если
/// таких столбцов нет.
/// Может применяться при инициализации просмотра для определения начального
/// активного столбца
/// </summary>
public int FirstIncSearchColumnIndex
{
get
{
for (int i = 0; i < Columns.Count; i++)
{
if (Columns[i].CanIncSearch)
return i;
}
return -1;
}
}
#endregion
#region Свойство CurrentGridConfig
/// <summary>
/// Выбранная настройка табличного просмотра.
/// Если свойство GridProducer не установлено, должен быть задан обработчик CurrentGridConfigChanged,
/// который выполнит реальную настройку просмотра
/// </summary>
public EFPDataGridViewConfig CurrentConfig
{
get { return _CurrentConfig; }
set
{
if (value == _CurrentConfig)
return; // предотвращение рекурсивной установки
if (value != null)
value.SetReadOnly();
_CurrentConfig = value;
if (!InsideSetCurrentConfig)
{
InsideSetCurrentConfig = true;
try
{
CancelEventArgs Args = new CancelEventArgs();
Args.Cancel = false;
OnCurrentConfigChanged(Args);
if ((!Args.Cancel) && (GridProducer != null))
{
//Control.Columns.Clear(); // 21.01.2012
this.Columns.Clear(); // 10.01.2016
//int nCols1 = Control.Columns.Count;
GridProducer.InitGridView(this, CurrentConfigHasBeenSet);
//int nCols2 = Control.Columns.Count;
PerformGridProducerPostInit();
}
}
finally
{
InsideSetCurrentConfig = false;
}
}
_CurrentConfigHasBeenSet = true;
}
}
private EFPDataGridViewConfig _CurrentConfig;
/// <summary>
/// Флажок нахождения в пределах сеттера свойства CurrentConfig.
/// </summary>
protected bool InsideSetCurrentConfig = false;
/// <summary>
/// Признак того, что свойство CurrentConfig уже устанавливалось
/// </summary>
protected bool CurrentConfigHasBeenSet { get { return _CurrentConfigHasBeenSet; } }
private bool _CurrentConfigHasBeenSet = false;
/// <summary>
/// Вызывается при изменении свойства CurrentConfig.
/// Если аргумент Cancel обработчиком установлен в true, то предполагается,
/// что инициализация просмотра выполнена в обработчике. В противном случае
/// (по умолчанию Cancel=false или при отстутствии обработчика) будет вызван
/// метод GridProducer.InitGrid()
/// </summary>
public event CancelEventHandler CurrentConfigChanged;
/// <summary>
/// Вызывает событие CurrentConfigChanged.
/// </summary>
/// <param name="args">Аргументы события</param>
protected virtual void OnCurrentConfigChanged(CancelEventArgs args)
{
if (CurrentConfigChanged != null)
CurrentConfigChanged(this, args);
}
/// <summary>
/// Это событие вызывается после того, как конфигурация табличного просмотра инициализирована
/// с помощью GridProducer.InitGrid()
/// </summary>
public event EventHandler GridProducerPostInit;
/// <summary>
/// Вызывает событие GridProducerPostInit
/// </summary>
public void PerformGridProducerPostInit()
{
// 12.10.2016
// Проверка недействительна
// В DBxDocGridView свойство GridProducer не устанавливается
//#if DEBUG
// if (GridProducer==null)
// throw new InvalidOperationException("Этот метод не может быть вызван, если свойство GridProducer не установлено");
//#endif
OnGridProducerPostInit();
}
/// <summary>
/// Вызывает событие GridProducerPostInit
/// </summary>
protected virtual void OnGridProducerPostInit()
{
if (GridProducerPostInit != null)
GridProducerPostInit(this, EventArgs.Empty);
}
#endregion
#region Установка отметок строк в столбце CheckBox
/// <summary>
/// Столбец CheckBox, с помощью которого устанавливаются отметки для строк
/// Если свойство установлено, то в локальном меню просмотра появляется
/// подменю "Установка отметок для строк"
/// Свойство может быть установлено при добавлении столбца с помощью аргумента
/// MarkRows в методе EFPDataGridViewColumns.AddBool()
/// Свойство следует устанавливать после добавления всех столбцов в просмотр,
/// но перед вызовом SetCommandItems(). Также допускается повторная установка свойства в процессе работы, если столбцы создаются заново
/// При установке свойства, если DataGridView.ReadOnly=true, устанавливается свойство
/// DataGridViewColumn.ReadOnly для всех столбцов, кроме заданного, а DataGridView.ReadOnly устанавливается в false.
/// Также устанавливается в true свойство DataGridView.MultiSelect=true.
/// </summary>
public DataGridViewCheckBoxColumn MarkRowsGridColumn
{
get { return _MarkRowsGridColumn; }
set
{
if (value == _MarkRowsGridColumn)
return;
#if DEBUG
// 13.05.2016
// Разрешена повторная установка свойства
//if (FMarkRowsGridColumn != null)
// throw new InvalidOperationException("Повторная установка свойства MarkRowsColumn не допускается");
//if (value == null)
// throw new ArgumentNullException("value");
if (value != null)
{
if (value.DataGridView != Control)
throw new ArgumentException("Столбец не принадлежит табличному просмотру", "value");
}
#endif
_MarkRowsGridColumn = value;
if (_MarkRowsGridColumn != null)
{
if (!HasBeenCreated) // 19.02.2021
{
// Отключаем команду "Select All", т.к. она не совместима по горячей клавише
CommandItems.UseSelectAll = false;
// Заменяем "таблицу для просмотра" на "столбцы для просмотра"
if (Control.ReadOnly)
{
Control.ReadOnly = false;
SetColumnsReadOnly(true);
}
// Разрешаем выбор множества строк
Control.MultiSelect = true;
}
_MarkRowsGridColumn.ReadOnly = false;
}
}
}
private DataGridViewCheckBoxColumn _MarkRowsGridColumn;
/// <summary>
/// Альтернативная установка свойства MarkRowsColumn
/// </summary>
public int MarkRowsColumnIndex
{
get
{
if (MarkRowsGridColumn == null)
return -1;
else
return MarkRowsGridColumn.Index;
}
set
{
if (value < 0)
MarkRowsGridColumn = null;
else
MarkRowsGridColumn = Control.Columns[value] as DataGridViewCheckBoxColumn;
}
}
/// <summary>
/// Задает один из столбцов с списке Columns для установки отметок строк.
/// По умолчанию возвращает null.
/// </summary>
public EFPDataGridViewColumn MarkRowsColumn
{
get
{
if (MarkRowsGridColumn == null)
return null;
else
return Columns[MarkRowsGridColumn];
}
set
{
if (value == null)
MarkRowsGridColumn = null;
else
MarkRowsGridColumn = value.GridColumn as DataGridViewCheckBoxColumn;
}
}
/// <summary>
/// Имя столбца в списке Columns, соответствующего MarkRowsColumn.
/// </summary>
public string MarkRowsColumnName
{
get
{
if (MarkRowsGridColumn == null)
return String.Empty;
else
return Columns[MarkRowsGridColumn].Name;
}
set
{
if (String.IsNullOrEmpty(value))
MarkRowsGridColumn = null;
else
MarkRowsGridColumn = (Columns[value].GridColumn) as DataGridViewCheckBoxColumn;
}
}
/// <summary>
/// Установка отметок в CheckBoxColumn для требуемых строк
/// Должно быть установлено свойство MarkRowsColumn
/// Скрытые строки пропускаются
/// </summary>
/// <param name="rows">Какие строки обрабатываются</param>
/// <param name="action">Установка, сброс или инверсия отметки</param>
/// <returns>Число строк, которые были изменены</returns>
public int CheckMarkRows(EFPDataGridViewCheckMarkRows rows, EFPDataGridViewCheckMarkAction action)
{
if (_MarkRowsGridColumn == null)
throw new InvalidOperationException("Свойство MarkRowsColumn не установлено");
// Отменяем режим редактирования и поиск по буквам
CurrentIncSearchColumn = null;
Control.EndEdit();
int ColumnIndex = _MarkRowsGridColumn.Index;
int cnt = 0;
switch (rows)
{
case EFPDataGridViewCheckMarkRows.Selected:
int[] SelRows = SelectedRowIndices;
for (int i = 0; i < SelRows.Length; i++)
{
if (CheckMarkRow(SelRows[i], ColumnIndex, action))
cnt++;
Control.InvalidateCell(ColumnIndex, SelRows[i]);
}
break;
case EFPDataGridViewCheckMarkRows.All:
for (int i = 0; i < Control.RowCount; i++)
{
if (CheckMarkRow(i, ColumnIndex, action))
cnt++;
}
Control.InvalidateColumn(ColumnIndex);
break;
default:
throw new ArgumentException("Неивестный Rows=" + rows.ToString(), "rows");
}
return cnt;
}
private bool CheckMarkRow(int rowIndex, int columnIndex, EFPDataGridViewCheckMarkAction action)
{
DataGridViewRow Row;
Row = Control.Rows.SharedRow(rowIndex);
if (Row.Index >= 0)
{
// Для разделяемой строки такое действие не допускается
if (!Row.Visible)
return false;
if (Row.ReadOnly)
return false;
}
/*EFPDataGridViewRowAttributesEventArgs RowArgs = */
DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.View);
EFPDataGridViewCellAttributesEventArgs CellArgs = DoGetCellAttributes(columnIndex);
bool OrgValue = DataTools.GetBool(CellArgs.Value);
bool NewValue;
switch (action)
{
case EFPDataGridViewCheckMarkAction.Check:
NewValue = true;
break;
case EFPDataGridViewCheckMarkAction.Uncheck:
NewValue = false;
break;
case EFPDataGridViewCheckMarkAction.Invert:
NewValue = !OrgValue;
break;
default:
throw new ArgumentException("Неизвестный Action=" + action.ToString(), "action");
}
if (NewValue == OrgValue)
return false;
// Требуется не Shared-строка
Row = Control.Rows[rowIndex];
Row.Cells[columnIndex].Value = NewValue;
// 20.04.2014
OnCellFinished(rowIndex, columnIndex, EFPDataGridViewCellFinishedReason.MarkRow);
return true;
}
#endregion
#region Автоподбор высоты строки
/// <summary>
/// Режим автоматического подбора высоты строк.
/// По умолчанию автоподбор выключен (None).
/// Свойство может устанавливаться только до вывода управляющего элемента на экран
/// </summary>
public EFPDataGridViewAutoSizeRowsMode AutoSizeRowsMode
{
get { return _AutoSizeRowsMode; }
set
{
CheckHasNotBeenCreated();
_AutoSizeRowsMode = value;
if (value != EFPDataGridViewAutoSizeRowsMode.None)
Control.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None; // отключаем стандартные средства
}
}
private EFPDataGridViewAutoSizeRowsMode _AutoSizeRowsMode;
#endregion
#region Поддержка экспорта
/// <summary>
/// Получение двумерного массива текстовых значений для выбранных ячеек таблицы
/// </summary>
/// <param name="area">Выделенные ячейки</param>
/// <returns>Двумерный массив строк. Первый индекс соответствует строкам, второй - столбцам</returns>
public string[,] GetCellTextValues(EFPDataGridViewRectArea area)
{
string[,] a = new string[area.RowCount, area.ColumnCount];
for (int i = 0; i < area.RowCount; i++)
{
DoGetRowAttributes(area.RowIndices[i], EFPDataGridViewAttributesReason.View);
for (int j = 0; j < area.ColumnCount; j++)
{
EFPDataGridViewCellAttributesEventArgs CellArgs = DoGetCellAttributes(area.ColumnIndices[j]);
a[i, j] = DoGetCellTextValue(CellArgs);
}
}
return a;
}
private string DoGetCellTextValue(EFPDataGridViewCellAttributesEventArgs CellArgs)
{
if (CellArgs.FormattedValue == null)
return String.Empty;
else
return CellArgs.FormattedValue.ToString();
}
/// <summary>
/// Получение текстового значения для одной ячейки
/// </summary>
/// <param name="rowIndex">Индекс строки в просмотре</param>
/// <param name="columnIndex">Индекс столбца в просмотре</param>
/// <returns>Текстовое значение</returns>
public string GetCellTextValue(int rowIndex, int columnIndex)
{
DoGetRowAttributes(rowIndex, EFPDataGridViewAttributesReason.View);
EFPDataGridViewCellAttributesEventArgs CellArgs = DoGetCellAttributes(columnIndex);
return DoGetCellTextValue(CellArgs);
}
/// <summary>
/// Запись файла в формате HTML
/// </summary>
/// <param name="fileName">Путь к файлу</param>
/// <param name="settings">Настройки экспорта</param>
public void SaveHtml(string fileName, EFPDataGridViewExpHtmlSettings settings)
{
EFPDataGridViewExpHtml.SaveFile(this, fileName, settings);
}
/// <summary>
/// Запись файла в формате Excel-2003 (XML)
/// </summary>
/// <param name="fileName">Путь к файлу</param>
/// <param name="settings">Настройки экспорта</param>
public void SaveExcel2003(string fileName, EFPDataGridViewExpExcelSettings settings)
{
EFPDataGridViewExpExcel2003.SaveFile(this, fileName, settings);
}
/// <summary>
/// Запись файла в формате Excel-2007/2010 (XLSX)
/// Вызов этого метода требует наличия сборки ICSharpCode.SharpZipLib.dll
/// </summary>
/// <param name="fileName">Путь к файлу</param>
/// <param name="settings">Настройки экспорта</param>
public void SaveExcel2007(string fileName, EFPDataGridViewExpExcelSettings settings)
{
EFPDataGridViewExpExcel2007.SaveFile(this, fileName, settings);
}
/// <summary>
/// Запись файла в формате Open Office Calc (ODS)
/// Вызов этого метода требует наличия сборки ICSharpCode.SharpZipLib.dll
/// </summary>
/// <param name="fileName">Путь к файлу</param>
/// <param name="settings">Настройки экспорта</param>
public void SaveOpenOfficeCalc(string fileName, EFPDataGridViewExpExcelSettings settings)
{
EFPDataGridViewExpOpenOfficeCalc.SaveFile(this, fileName, settings);
}
/// <summary>
/// Получить массив строк и столбцов для записи в файл
/// </summary>
/// <param name="rangeMode">Заданный режим выделения</param>
/// <returns>Массив строк и столбцов</returns>
public EFPDataGridViewRectArea GetRectArea(EFPDataGridViewExpRange rangeMode)
{
switch (rangeMode)
{
case EFPDataGridViewExpRange.All:
return new EFPDataGridViewRectArea(Control, EFPDataGridViewRectAreaCreation.Visible);
case EFPDataGridViewExpRange.Selected:
return new EFPDataGridViewRectArea(Control, EFPDataGridViewRectAreaCreation.Selected);
default:
throw new ArgumentException("Неизвестный режим выделения: " + rangeMode.ToString(), "rangeMode");
}
}
/// <summary>
/// Используется при получении иерархических заголовков столбцов методами GetColumnHeaderArray().
/// Если true, то разрешено объединение по горизонтали для строк, когда выше имеются необъединенные ячейки.
/// Если false (по умолчанию), то заголовки являются строго иерархическими, при этом может быть повторяющийся текст.
/// </summary>
public bool ColumnHeaderMixedSpanAllowed
{
get { return _ColumnHeaderMixedSpanAllowed; }
set { _ColumnHeaderMixedSpanAllowed = value; }
}
private bool _ColumnHeaderMixedSpanAllowed;
/// <summary>
/// Возвращает массив заголовков столбцов, используемый при экспорте в электронные таблицы и других случаях, когда
/// поддерживаются многоуровневые заголовки
/// </summary>
/// <param name="columns">Столбцы</param>
/// <returns>Массив заголовков</returns>
public virtual EFPDataGridViewColumnHeaderArray GetColumnHeaderArray(EFPDataGridViewColumn[] columns)
{
// Метод переопределен в программе "Бюджетный учет" для поддержки заголовков из параметров страницы.
#if DEBUG
if (columns == null)
throw new ArgumentNullException("columns");
#endif
#region Получение массива заголовков столбцов
string[][] Headers = new string[columns.Length][];
for (int i = 0; i < columns.Length; i++)
{
Headers[i] = columns[i].PrintHeaders;
if (Headers[i] == null)
Headers[i] = new string[] { columns[i].GridColumn.HeaderText };
}
#endregion
EFPDataGridViewColumnHeaderArray ha = new EFPDataGridViewColumnHeaderArray(Headers, ColumnHeaderMixedSpanAllowed);
return ha;
}
/// <summary>
/// Создание описателей заголовков столбцов для выбранной области ячеек.
/// </summary>
/// <param name="area">Выбранная область. Используются только столбцы, строки игнорируются</param>
/// <returns>Описания столбцов</returns>
public /*virtual*/ EFPDataGridViewColumnHeaderArray GetColumnHeaderArray(EFPDataGridViewRectArea area)
{
#if DEBUG
if (area == null)
throw new ArgumentNullException("area");
#endif
EFPDataGridViewColumn[] SelCols = new EFPDataGridViewColumn[area.ColumnCount];
for (int i = 0; i < area.ColumnCount; i++)
SelCols[i] = Columns[area.ColumnIndices[i]];
return GetColumnHeaderArray(SelCols);
}
/// <summary>
/// Получить сводку документа при экспорте.
/// Реализация по умолчанию возвращает копию EFPApp.DefaultDocProperties
/// с установленным свойством Title в соответствии с DisplayName или
/// заголовком окна, если просмотр является единственным управляющим элементом
/// </summary>
public virtual EFPDocumentProperties DocumentProperties
{
// Свойство доопределяется в программе "Бюджетный учет" для учета имени текущего пользователя в качестве автора
get
{
EFPDocumentProperties Props = EFPApp.DefaultDocumentProperties;
//if (String.IsNullOrEmpty(DisplayName))
try
{
Props.Title = WinFormsTools.GetControlText(Control);
}
catch
{
}
//else
// Props.Title = DisplayName;
return Props;
}
}
/// <summary>
/// Возвращает true, если есть установленная версия Microsoft Excel, в которую можно выполнить передачу данных табличного просмотра
/// </summary>
public static bool CanSendToMicrosoftExcel
{
get
{
// Для версии XP и новее выполняется создание файла в XML-формате,
// Для версии 2000 выполняется прямое манипулирование OLE-объектом
return EFPApp.MicrosoftExcelVersion.Major >= MicrosoftOfficeTools.MicrosoftOffice_2000;
}
}
/// <summary>
/// Возвращает true, если есть установленная версия Open Office или Libre Office Calc, в которую можно выполнить передачу данных табличного просмотра
/// </summary>
public static bool CanSendToOpenOfficeCalc
{
[DebuggerStepThrough] // подавление остановки в отладчике при возникновении исключения
get
{
return EFPApp.OpenOfficeCalcVersion.Major >= 3
&& ZipFileTools.ZipLibAvailable; // 25.01.2014
}
}
/// <summary>
/// Передача данных табличного просмотра в Microsoft Excel.
/// Создается новая книга с одним листом, содержащим все или только выбранные ячейки табличного просмотра
/// </summary>
/// <param name="settings">Параметры передачи</param>
public void SendToMicrosoftExcel(EFPDataGridViewExpExcelSettings settings)
{
EFPDataGridViewSendToExcel.SendTable(this, settings);
}
/// <summary>
/// Передача данных табличного просмотра в Open Office Calc или Libre Office Calc.
/// Создается новая книга с одним листом, содержащим все или только выбранные ячейки табличного просмотра
/// </summary>
/// <param name="settings">Параметры передачи</param>
public void SendToOpenOfficeCalc(EFPDataGridViewExpExcelSettings settings)
{
EFPDataGridViewSendToOpenOfficeCalc.SendTable(this, settings);
}
#endregion
#region Отладка SharedRow
/// <summary>
/// Для отладочных целей.
/// Посчитать, сколько строк Shared.
/// Выполняется медленно, т.к. требцется перебрать все строки в просмотре.
/// </summary>
public int UnsharedRowCount
{
get
{
int cnt = 0;
int n = Control.RowCount;
for (int i = 0; i < n; i++)
{
DataGridViewRow Row = Control.Rows.SharedRow(i);
if (Row.Index >= 0)
cnt++;
}
return cnt;
}
}
/// <summary>
/// Для отладочных целей.
/// Возвращает количество строк в просмотре, для которых еще не было выполнено Unshare.
/// Выполняется медленно, т.к. требцется перебрать все строки в просмотре.
/// </summary>
public int SharedRowCount
{
get
{
int cnt = 0;
int n = Control.RowCount;
for (int i = 0; i < n; i++)
{
DataGridViewRow Row = Control.Rows.SharedRow(i);
if (Row.Index < 0)
cnt++;
}
return cnt;
}
}
#endregion
#region Получение EFPDataViewRowInfo
private DataRowValueArray _RowValueArray;
/// <summary>
/// Получить объект EFPDataViewRowInfo для строки.
/// Когда он больше не нужен, должен быть вызван FreeRowInfo()
/// </summary>
/// <param name="rowIndex">Индекс строки табличного просмотра</param>
/// <returns>Информация о строке</returns>
public EFPDataViewRowInfo GetRowInfo(int rowIndex)
{
IDataRowNamedValuesAccess rwa = _RowValueArray;
if (rwa == null) // Первый вызов или вложенный
rwa = CreateRowValueAccessObject();
// 06.07.2021
// Если использовать таблицу-повторитель, а не исходную таблицу, то возникает проблема в EFPSubDocGridView (ExtDBDocForms.dll).
// Если выполняется команда "Создать копию", то для ссылочных полей значения, ссылающиеся на поддокументы этого же документа,
// не будут возвращаться. Для таких ссылок используются фиктивные отрицательные идентификаторы. DBxDocTextHandlers
// использует поиск в наборе данных DataSet, к которому относится строка DataRow. Для таблицы-повторителя нет набора
// данных. Без таблицы-повторителя-это набор данных, относящийся к DBxDocSet, который позволяет получить значения для всех фиктивных ссылок.
// Поэтому, строка DataRowValueArray.CurrentRow должна относиться к мастер-таблице, если используется повторитель.
//rwa.CurrentRow = GetDataRow(rowIndex);
rwa.CurrentRow = GetMasterRow(GetDataRow(rowIndex));
return new EFPDataViewRowInfo(this, rwa.CurrentRow, rwa, rowIndex);
}
/// <summary>
/// Создает объект DataRowValueArray для доступа к данным.
/// Класс-наследник может создавать объект, который, например, использует буферизацию данных
/// </summary>
/// <returns>Объект для доступа к данным</returns>
protected virtual IDataRowNamedValuesAccess CreateRowValueAccessObject()
{
return new DataRowValueArray();
}
/// <summary>
/// Освободить данные, полученные GetRowInfo().
/// </summary>
/// <param name="rowInfo"></param>
public void FreeRowInfo(EFPDataViewRowInfo rowInfo)
{
_RowValueArray = rowInfo.Values as DataRowValueArray; // для повторного использования.
// if (_RowValueArray != null)
// _RowValueArray.CurrentRow = null;
}
#endregion
}
/// <summary>
/// Исключение, выбрасываемое, если источник данных (например, свойство DataGridView.DataSource)
/// имеет неподходящий тип.
/// </summary>
[Serializable]
public class InvalidDataSourceException : ApplicationException
{
#region Конструктор
/// <summary>
/// Создает новый объект исключения
/// </summary>
/// <param name="message">Сообщение</param>
public InvalidDataSourceException(string message)
: this(message, null)
{
}
/// <summary>
/// Создает новый объект исключения с вложенным исключением
/// </summary>
/// <param name="message">Сообщение</param>
/// <param name="innerException">Вложенное исключение</param>
public InvalidDataSourceException(string message, Exception innerException)
: base(message, innerException)
{
}
/// <summary>
/// Эта версия конструктора нужна для правильной десериализации
/// </summary>
protected InvalidDataSourceException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
#endregion
}
}
| 32.33763 | 165 | 0.634126 | [
"BSD-2-Clause"
] | a94827/FreeLibSet | ExtForms/EFPControls/EFPDataGridView.cs | 371,255 | C# |
#pragma warning disable 108 // new keyword hiding
#pragma warning disable 114 // new keyword hiding
namespace Windows.System.Diagnostics
{
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
#endif
public partial class ProcessDiskUsageReport
{
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
public long BytesReadCount
{
get
{
throw new global::System.NotImplementedException("The member long ProcessDiskUsageReport.BytesReadCount is not implemented in Uno.");
}
}
#endif
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
public long BytesWrittenCount
{
get
{
throw new global::System.NotImplementedException("The member long ProcessDiskUsageReport.BytesWrittenCount is not implemented in Uno.");
}
}
#endif
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
public long OtherBytesCount
{
get
{
throw new global::System.NotImplementedException("The member long ProcessDiskUsageReport.OtherBytesCount is not implemented in Uno.");
}
}
#endif
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
public long OtherOperationCount
{
get
{
throw new global::System.NotImplementedException("The member long ProcessDiskUsageReport.OtherOperationCount is not implemented in Uno.");
}
}
#endif
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
public long ReadOperationCount
{
get
{
throw new global::System.NotImplementedException("The member long ProcessDiskUsageReport.ReadOperationCount is not implemented in Uno.");
}
}
#endif
#if __ANDROID__ || __IOS__ || NET461 || __WASM__ || __MACOS__
[global::Uno.NotImplemented]
public long WriteOperationCount
{
get
{
throw new global::System.NotImplementedException("The member long ProcessDiskUsageReport.WriteOperationCount is not implemented in Uno.");
}
}
#endif
// Forced skipping of method Windows.System.Diagnostics.ProcessDiskUsageReport.ReadOperationCount.get
// Forced skipping of method Windows.System.Diagnostics.ProcessDiskUsageReport.WriteOperationCount.get
// Forced skipping of method Windows.System.Diagnostics.ProcessDiskUsageReport.OtherOperationCount.get
// Forced skipping of method Windows.System.Diagnostics.ProcessDiskUsageReport.BytesReadCount.get
// Forced skipping of method Windows.System.Diagnostics.ProcessDiskUsageReport.BytesWrittenCount.get
// Forced skipping of method Windows.System.Diagnostics.ProcessDiskUsageReport.OtherBytesCount.get
}
}
| 35.012821 | 142 | 0.751373 | [
"Apache-2.0"
] | 06needhamt/uno | src/Uno.UWP/Generated/3.0.0.0/Windows.System.Diagnostics/ProcessDiskUsageReport.cs | 2,731 | C# |
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license.
//
// Microsoft Cognitive Services (formerly Project Oxford): https://www.microsoft.com/cognitive-services
//
// Microsoft Cognitive Services (formerly Project Oxford) GitHub:
// https://github.com/Microsoft/Cognitive-Face-Windows
//
// Copyright (c) Microsoft Corporation
// All rights reserved.
//
// MIT License:
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
namespace Microsoft.ProjectOxford.Face.Contract
{
/// <summary>
/// The face list class
/// </summary>
public class FaceList : FaceListMetadata
{
#region Properties
/// <summary>
/// Gets or sets the persisted faces.
/// </summary>
/// <value>
/// The persisted faces.
/// </value>
public PersonFace[] PersistedFaces
{
get; set;
}
#endregion Properties
}
}
| 34.526316 | 103 | 0.697154 | [
"MIT"
] | AlejandroRuiz/XamarinFestLive | Cognitive Services/CognitiveServices/Microsoft.ProjectOxford.Face/Contract/FaceList.cs | 1,970 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace Net5MvcApp
{
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
}
| 26.592593 | 71 | 0.62117 | [
"MIT"
] | AdrianaDJ/Oryx | tests/SampleApps/DotNetCore/Net5MvcApp/Program.cs | 692 | C# |
using System.Collections.Generic;
namespace dotdigital.Api.Resources.Models
{
public class ApiDocumentFolder
{
public int Id
{ get; set; }
public string Name
{ get; set; }
public ApiDocumentFolderList ChildFolders
{ get; set; }
}
}
| 14.705882 | 43 | 0.712 | [
"MIT"
] | cookfood/dotdigitaldotnet | dotMailer.Api/Resources/Models/ApiDocumentFolder.cs | 250 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Identity;
namespace PostgreSQL.Demo.Models
{
// Add profile data for application users by adding properties to the ApplicationUser class
public class ApplicationUser : IdentityUser
{
}
}
| 23.5 | 95 | 0.775076 | [
"MIT"
] | 0xRumple/postgres-aspcore-docker-demo | Models/ApplicationUser.cs | 331 | C# |
using Microsoft.EntityFrameworkCore;
namespace Centeva.Data {
public abstract class DbContextMiddleware {
public virtual void BeforeModelCreating(DbContext context, ModelBuilder modelBuilder) { }
public virtual void AfterModelCreating(DbContext context, ModelBuilder modelBuilder) { }
public virtual void BeforeSaveChanges(DbContext context) { }
public virtual void AfterSaveChanges(DbContext context) { }
}
}
| 39.181818 | 92 | 0.791183 | [
"MIT"
] | Centeva/Centeva.Data.EfCore | DbContextMiddleware.cs | 431 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management.Automation;
using System.Management.Automation.Runspaces;
using System.Threading;
namespace ScriptHost
{
public class PowerShell
{
public Runspace Runspace { get; set; }
public Pipeline Pipeline { get; set; }
public string Module { get; set; }
public bool Print { get; set; }
public List<string> Scripts { get; } = new List<string>();
public string[] Parameters { get; }
public static List<PowerShell> Instances { get; } = new List<PowerShell>();
string BR = Environment.NewLine;
public object Invoke() => Invoke(null, null);
public object Invoke(string variable, object obj)
{
try
{
Runspace = RunspaceFactory.CreateRunspace();
Runspace.ApartmentState = ApartmentState.STA;
Runspace.Open();
Pipeline = Runspace.CreatePipeline();
foreach (string script in Scripts)
Pipeline.Commands.AddScript(script);
if (Parameters != null)
foreach (string param in Parameters)
foreach (Command command in Pipeline.Commands)
command.Parameters.Add(null, param);
Runspace.SessionStateProxy.SetVariable("ScriptHost", this);
if (!string.IsNullOrEmpty(variable))
Runspace.SessionStateProxy.SetVariable(variable, obj);
if (Print)
{
Pipeline.Output.DataReady += Output_DataReady;
Pipeline.Error.DataReady += Error_DataReady;
}
return Pipeline.Invoke();
}
catch (RuntimeException e)
{
string message = e.Message + BR + BR + e.ErrorRecord.ScriptStackTrace.Replace(
" <ScriptBlock>, <No file>", "") + BR + BR + Module + BR;
throw new PowerShellException(message);
}
catch (Exception e)
{
throw e;
}
}
public static string InvokeAndReturnString(string code, string varName, object varValue)
{
PowerShell ps = new PowerShell() { Print = false };
ps.Scripts.Add(code);
string ret = string.Join(Environment.NewLine, (ps.Invoke(varName, varValue)
as IEnumerable<object>).Select(item => item.ToString())).ToString();
ps.Runspace.Dispose();
return ret;
}
public void Output_DataReady(object sender, EventArgs e)
{
var output = sender as PipelineReader<PSObject>;
while (output.Count > 0)
ConsoleHelp.Write(output.Read(), Module);
}
public void Error_DataReady(object sender, EventArgs e)
{
var output = sender as PipelineReader<Object>;
while (output.Count > 0)
ConsoleHelp.WriteError(output.Read(), Module);
}
public void RedirectEventJobStreams(PSEventJob job)
{
if (Print)
{
job.Output.DataAdded += Output_DataAdded;
job.Error.DataAdded += Error_DataAdded;
}
}
void Output_DataAdded(object sender, DataAddedEventArgs e)
{
var output = sender as PSDataCollection<PSObject>;
ConsoleHelp.Write(output[e.Index], Module);
}
void Error_DataAdded(object sender, DataAddedEventArgs e)
{
var error = sender as PSDataCollection<ErrorRecord>;
ConsoleHelp.WriteError(error[e.Index], Module);
}
}
public class PowerShellException : Exception
{
public PowerShellException(string message) : base(message)
{
}
}
}
| 32.129032 | 96 | 0.550703 | [
"MIT"
] | minute/mpv.net | mpv.net/Scripting/PowerShell.cs | 3,986 | C# |
using System.Drawing;
using System.Collections.Generic;
using MonoTouch.UIKit;
using MonoTouch.CoreGraphics;
namespace UIKitPlayground.UIGravityBehaviorRecipe {
public class ChangingGravityViewController : UIViewController {
UIDynamicAnimator animator;
UIGravityBehavior gravity;
readonly Queue<UIView> items = new Queue<UIView>();
static readonly SizeF sizeInitial = new SizeF(25f, 25f);
public override void ViewDidLoad() {
base.ViewDidLoad();
View.BackgroundColor = UIColor.White;
animator = new UIDynamicAnimator(View);
gravity = new UIGravityBehavior();
animator.AddBehavior(gravity);
// Tap to add new item.
View.AddGestureRecognizer(new UITapGestureRecognizer((gesture) => {
PointF tapLocation = gesture.LocationInView(View);
var item = new UIView(new RectangleF(PointF.Empty, sizeInitial)) {
BackgroundColor = ColorHelpers.GetRandomColor(),
Center = tapLocation,
};
items.Enqueue(item);
View.Add(item);
gravity.AddItem(item);
// Clean up old items so things don't get too leaky.
if (items.Count > 20) {
var oldItem = items.Dequeue();
oldItem.RemoveFromSuperview();
gravity.RemoveItem(oldItem);
oldItem.Dispose();
}
}));
// Swipe to change gravity direction.
View.AddGestureRecognizer(new UISwipeGestureRecognizer((gesture) => {
gravity.GravityDirection = new CGVector(1, 0);
}) { Direction = UISwipeGestureRecognizerDirection.Right, });
View.AddGestureRecognizer(new UISwipeGestureRecognizer((gesture) => {
gravity.GravityDirection = new CGVector(-1, 0);
}) { Direction = UISwipeGestureRecognizerDirection.Left, });
View.AddGestureRecognizer(new UISwipeGestureRecognizer((gesture) => {
gravity.GravityDirection = new CGVector(0, -1);
}) { Direction = UISwipeGestureRecognizerDirection.Up, });
View.AddGestureRecognizer(new UISwipeGestureRecognizer((gesture) => {
gravity.GravityDirection = new CGVector(0, 1);
}) { Direction = UISwipeGestureRecognizerDirection.Down, });
}
public override bool PrefersStatusBarHidden() {
return true;
}
}
} | 44.525424 | 83 | 0.582033 | [
"MIT"
] | patridge/UIGravityBehaviorRecipe | UIGravityBehaviorRecipe/ChangingGravityViewController.cs | 2,627 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// このコードはツールによって生成されました。
// ランタイム バージョン:4.0.30319.42000
//
// このファイルへの変更は、以下の状況下で不正な動作の原因になったり、
// コードが再生成されるときに損失したりします。
// </auto-generated>
//------------------------------------------------------------------------------
namespace ShowMeTheXAMLTest.Properties {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.5.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default {
get {
return defaultInstance;
}
}
}
}
| 37.666667 | 151 | 0.580138 | [
"MIT"
] | soi013/ShowMeTheXAMLTest | ShowMeTheXAMLTest -Source/ShowMeTheXAMLTest/Properties/Settings.Designer.cs | 1,191 | C# |
/******************************************************
* ROMVault3 is written by Gordon J. *
* Contact [email protected] *
* Copyright 2010 *
******************************************************/
using System;
using System.Diagnostics;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
using RVCore;
using RVCore.FindFix;
using RVCore.ReadDat;
using RVCore.RvDB;
using RVCore.Scanner;
using RVIO;
namespace ROMVault
{
public partial class FrmMain : Form
{
private static readonly Color CBlue = Color.FromArgb(214, 214, 255);
private static readonly Color CGreyBlue = Color.FromArgb(214, 224, 255);
private static readonly Color CRed = Color.FromArgb(255, 214, 214);
private static readonly Color CBrightRed = Color.FromArgb(255, 0, 0);
private static readonly Color CGreen = Color.FromArgb(214, 255, 214);
private static readonly Color CGrey = Color.FromArgb(214, 214, 214);
private static readonly Color CCyan = Color.FromArgb(214, 255, 255);
private static readonly Color CCyanGrey = Color.FromArgb(214, 225, 225);
private static readonly Color CMagenta = Color.FromArgb(255, 214, 255);
private static readonly Color CBrown = Color.FromArgb(140, 80, 80);
private static readonly Color CPurple = Color.FromArgb(214, 140, 214);
private static readonly Color CYellow = Color.FromArgb(255, 255, 214);
private static readonly Color COrange = Color.FromArgb(255, 214, 140);
private static readonly Color CWhite = Color.FromArgb(255, 255, 255);
private static int[] _gameGridColumnXPositions;
private readonly Color[] _displayColor;
private readonly Color[] _fontColor;
private readonly ContextMenu _mnuContext;
private readonly ContextMenu _mnuContextToSort;
private readonly MenuItem _mnuFile;
private readonly MenuItem _mnuOpen;
private readonly MenuItem _mnuToSortScan;
private readonly MenuItem _mnuToSortOpen;
private readonly MenuItem _mnuToSortDelete;
private readonly MenuItem _mnuToSortSetPrimary;
private readonly MenuItem _mnuToSortSetCache;
private RvFile _clickedTree;
private bool _updatingGameGrid;
private FrmKey _fk;
private float _scaleFactorX = 1;
private float _scaleFactorY = 1;
public FrmMain()
{
InitializeComponent();
AddGameMetaData();
Text = $@"RomVault ({Program.StrVersion}) {Application.StartupPath}";
_displayColor = new Color[(int)RepStatus.EndValue];
_fontColor = new Color[(int)RepStatus.EndValue];
// RepStatus.UnSet
_displayColor[(int)RepStatus.UnScanned] = CBlue;
_displayColor[(int)RepStatus.DirCorrect] = CGreen;
_displayColor[(int)RepStatus.DirMissing] = CRed;
_displayColor[(int)RepStatus.DirCorrupt] = CBrightRed; //BrightRed
_displayColor[(int)RepStatus.Missing] = CRed;
_displayColor[(int)RepStatus.Correct] = CGreen;
_displayColor[(int)RepStatus.NotCollected] = CGrey;
_displayColor[(int)RepStatus.UnNeeded] = CCyanGrey;
_displayColor[(int)RepStatus.Unknown] = CCyan;
_displayColor[(int)RepStatus.InToSort] = CMagenta;
_displayColor[(int)RepStatus.Corrupt] = CBrightRed; //BrightRed
_displayColor[(int)RepStatus.Ignore] = CGreyBlue;
_displayColor[(int)RepStatus.CanBeFixed] = CYellow;
_displayColor[(int)RepStatus.MoveToSort] = CPurple;
_displayColor[(int)RepStatus.Delete] = CBrown;
_displayColor[(int)RepStatus.NeededForFix] = COrange;
_displayColor[(int)RepStatus.Rename] = COrange;
_displayColor[(int)RepStatus.CorruptCanBeFixed] = CYellow;
_displayColor[(int)RepStatus.MoveToCorrupt] = CPurple; //Missing
_displayColor[(int)RepStatus.Deleted] = CWhite;
for (int i = 0; i < (int)RepStatus.EndValue; i++)
{
_fontColor[i] = Contrasty(_displayColor[i]);
}
_gameGridColumnXPositions = new int[(int)RepStatus.EndValue];
DirTree.Setup(ref DB.DirTree);
splitContainer3_Panel1_Resize(new object(), new EventArgs());
splitContainer4_Panel1_Resize(new object(), new EventArgs());
_mnuContext = new ContextMenu();
MenuItem mnuScan = new MenuItem
{
Text = @"Scan",
Tag = null
};
_mnuFile = new MenuItem
{
Text = @"Set Dir Settings",
Tag = null
};
_mnuOpen = new MenuItem
{
Text = @"Open",
Tag = null
};
MenuItem mnuFixDat = new MenuItem
{
Text = @"Create Fix DATs",
Tag = null
};
MenuItem mnuMakeDat = new MenuItem
{
Text = @"Make Dat with CHDs as disk",
Tag = null
};
MenuItem mnuMakeDat2 = new MenuItem
{
Text = @"Make Dat with CHDs as rom",
Tag = null
};
_mnuContext.MenuItems.Add(mnuScan);
_mnuContext.MenuItems.Add(_mnuOpen);
_mnuContext.MenuItems.Add(_mnuFile);
_mnuContext.MenuItems.Add(mnuFixDat);
_mnuContext.MenuItems.Add(mnuMakeDat);
_mnuContext.MenuItems.Add(mnuMakeDat2);
mnuScan.Click += MnuToSortScan;
_mnuOpen.Click += MnuOpenClick;
_mnuFile.Click += MnuFileClick;
mnuFixDat.Click += MnuMakeFixDatClick;
mnuMakeDat.Click += MnuMakeDatClick;
mnuMakeDat2.Click += MnuMakeDat2Click;
_mnuContextToSort = new ContextMenu();
_mnuToSortScan = new MenuItem
{
Text = @"Scan",
Tag = null
};
_mnuToSortOpen = new MenuItem
{
Text = @"Open",
Tag = null
};
_mnuToSortDelete = new MenuItem
{
Text = @"Remove",
Tag = null
};
_mnuToSortSetPrimary = new MenuItem
{
Text = @"Set To Primary ToSort",
Tag = null
};
_mnuToSortSetCache = new MenuItem
{
Text = @"Set To Cache ToSort",
Tag = null
};
_mnuContextToSort.MenuItems.Add(_mnuToSortScan);
_mnuContextToSort.MenuItems.Add(_mnuToSortOpen);
_mnuContextToSort.MenuItems.Add(_mnuToSortDelete);
_mnuContextToSort.MenuItems.Add(_mnuToSortSetPrimary);
_mnuContextToSort.MenuItems.Add(_mnuToSortSetCache);
_mnuToSortScan.Click += MnuToSortScan;
_mnuToSortOpen.Click += MnuToSortOpen;
_mnuToSortDelete.Click += MnuToSortDelete;
_mnuToSortSetPrimary.Click += MnuToSortSetPrimary;
_mnuToSortSetCache.Click += MnuToSortSetCache;
chkBoxShowCorrect.Checked = Settings.rvSettings.chkBoxShowCorrect;
chkBoxShowMissing.Checked = Settings.rvSettings.chkBoxShowMissing;
chkBoxShowFixed.Checked = Settings.rvSettings.chkBoxShowFixed;
chkBoxShowMerged.Checked = Settings.rvSettings.chkBoxShowMerged;
TabArtworkInitialize();
}
// returns either white or black, depending of quick luminance of the Color " a "
// called when the _displayColor is finished, in order to populate the _fontColor table.
private static Color Contrasty(Color a)
{
return (a.R << 1) + a.B + a.G + (a.G << 2) < 1024 ? Color.White : Color.Black;
}
public sealed override string Text
{
get => base.Text;
set => base.Text = value;
}
protected override void ScaleControl(SizeF factor, BoundsSpecified specified)
{
base.ScaleControl(factor, specified);
splitToolBarMain.SplitterDistance = (int)(splitToolBarMain.SplitterDistance * factor.Width);
splitDatInfoGameInfo.SplitterDistance = (int)(splitDatInfoGameInfo.SplitterDistance * factor.Width);
splitDatInfoGameInfo.Panel1MinSize = (int)(splitDatInfoGameInfo.Panel1MinSize * factor.Width);
splitDatInfoTree.SplitterDistance = (int)(splitDatInfoTree.SplitterDistance * factor.Height);
splitGameInfoLists.SplitterDistance = (int)(splitGameInfoLists.SplitterDistance * factor.Height);
_scaleFactorX *= factor.Width;
_scaleFactorY *= factor.Height;
}
private void AddTextBox(int line, string name, int x, int x1, out Label lBox, out TextBox tBox)
{
int y = 14 + line * 16;
lBox = new Label
{
Location = SPoint(x, y + 1),
Size = SSize(x1 - x - 2, 13),
Text = name + @" :",
TextAlign = ContentAlignment.TopRight
};
tBox = new TextBox
{
AutoSize = false,
Location = SPoint(x1, y),
Size = SSize(20, 17),
BorderStyle = BorderStyle.FixedSingle,
ReadOnly = true,
TabStop = false
};
gbSetInfo.Controls.Add(lBox);
gbSetInfo.Controls.Add(tBox);
}
private Point SPoint(int x, int y)
{
return new Point((int)(x * _scaleFactorX), (int)(y * _scaleFactorY));
}
private Size SSize(int x, int y)
{
return new Size((int)(x * _scaleFactorX), (int)(y * _scaleFactorY));
}
private void DirTreeRvChecked(object sender, MouseEventArgs e)
{
RepairStatus.ReportStatusReset(DB.DirTree);
DatSetSelected(DirTree.Selected);
}
private void DirTreeRvSelected(object sender, MouseEventArgs e)
{
RvFile cf = (RvFile)sender;
if (cf != DirTree.GetSelected())
{
DatSetSelected(cf);
}
if (e.Button != MouseButtons.Right)
{
return;
}
_clickedTree = (RvFile)sender;
Point controLocation = ControlLoc(DirTree);
if (cf.IsInToSort)
{
bool selected = (_clickedTree.Tree.Checked != RvTreeRow.TreeSelect.Locked);
_mnuToSortOpen.Enabled = Directory.Exists(_clickedTree.FullName);
_mnuToSortDelete.Enabled = !(_clickedTree.FileStatusIs(FileStatus.PrimaryToSort) |
_clickedTree.FileStatusIs(FileStatus.CacheToSort));
_mnuToSortSetCache.Enabled = selected;
_mnuToSortSetPrimary.Enabled = selected;
_mnuContextToSort.Show(this, new Point(controLocation.X + e.X - 32, controLocation.Y + e.Y - 10));
}
else
{
_mnuOpen.Enabled = Directory.Exists(_clickedTree.FullName);
//_mnuFile.Enabled = _clickedTree.Dat == null;
_mnuContext.Show(this, new Point(controLocation.X + e.X - 32, controLocation.Y + e.Y - 10));
}
}
private Point ControlLoc(Control c)
{
Point ret = new Point(c.Left, c.Top);
if (c.Parent == this)
return ret;
Point pNext = ControlLoc(c.Parent);
ret.X += pNext.X;
ret.Y += pNext.Y;
return ret;
}
private void MnuFileClick(object sender, EventArgs e)
{
using (FrmSetDirSettings sd = new FrmSetDirSettings())
{
string tDir = _clickedTree.TreeFullName;
sd.SetLocation(tDir);
sd.SetDisplayType(true);
sd.ShowDialog(this);
if (sd.ChangesMade)
UpdateDats();
}
}
private void MnuOpenClick(object sender, EventArgs e)
{
string tDir = _clickedTree.FullName;
if (Directory.Exists(tDir))
Process.Start(tDir);
}
private void MnuMakeFixDatClick(object sender, EventArgs e)
{
Report.MakeFixFiles(_clickedTree);
}
private void MnuMakeDatClick(object sender, EventArgs e)
{
SaveFileDialog browse = new SaveFileDialog
{
Filter = "DAT file|*.dat",
Title = "Save an Dat File",
FileName = _clickedTree.Name
};
if (browse.ShowDialog() != DialogResult.OK)
{
return;
}
if (browse.FileName == "")
{
return;
}
DatMaker.MakeDatFromDir(_clickedTree, browse.FileName);
}
private void MnuMakeDat2Click(object sender, EventArgs e)
{
SaveFileDialog browse = new SaveFileDialog
{
Filter = "DAT file|*.dat",
Title = "Save an Dat File",
FileName = _clickedTree.Name
};
if (browse.ShowDialog() != DialogResult.OK)
{
return;
}
if (browse.FileName == "")
{
return;
}
DatMaker.MakeDatFromDir(_clickedTree, browse.FileName, false);
}
private void AddToSortToolStripMenuItem_Click(object sender, EventArgs e)
{
FolderBrowserDialog folderBrowserDialog1 = new FolderBrowserDialog();
DialogResult result = folderBrowserDialog1.ShowDialog();
if (result != DialogResult.OK) return;
RvFile ts = new RvFile(FileType.Dir)
{
Name = folderBrowserDialog1.SelectedPath,
Tree = new RvTreeRow { Checked = RvTreeRow.TreeSelect.Locked },
DatStatus = DatStatus.InDatCollect
};
DB.DirTree.ChildAdd(ts, DB.DirTree.ChildCount);
RepairStatus.ReportStatusReset(DB.DirTree);
DirTree.Setup(ref DB.DirTree);
DatSetSelected(ts);
DB.Write();
}
private void MnuToSortScan(object sender, EventArgs e)
{
ScanRoms(Settings.rvSettings.ScanLevel, _clickedTree);
}
private void MnuToSortOpen(object sender, EventArgs e)
{
string tDir = _clickedTree.FullName;
if (Directory.Exists(tDir))
Process.Start(tDir);
}
private void MnuToSortDelete(object sender, EventArgs e)
{
for (int i = 0; i < DB.DirTree.ChildCount; i++)
{
if (DB.DirTree.Child(i) == _clickedTree)
{
DB.DirTree.ChildRemove(i);
RepairStatus.ReportStatusReset(DB.DirTree);
DirTree.Setup(ref DB.DirTree);
DatSetSelected(DB.DirTree.Child(i - 1));
DB.Write();
DirTree.Refresh();
return;
}
}
}
private void MnuToSortSetPrimary(object sender, EventArgs e)
{
if (_clickedTree.Tree.Checked == RvTreeRow.TreeSelect.Locked)
{
MessageBox.Show("Directory Must be ticked.", "RomVault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
RvFile t = DB.RvFileToSort();
bool wasCache = t.FileStatusIs(FileStatus.CacheToSort);
t.FileStatusClear(FileStatus.PrimaryToSort | FileStatus.CacheToSort);
_clickedTree.FileStatusSet(FileStatus.PrimaryToSort);
if (wasCache)
_clickedTree.FileStatusSet(FileStatus.CacheToSort);
DB.Write();
DirTree.Refresh();
}
private void MnuToSortSetCache(object sender, EventArgs e)
{
if (_clickedTree.Tree.Checked == RvTreeRow.TreeSelect.Locked)
{
MessageBox.Show("Directory Must be ticked.", "RomVault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
RvFile t = DB.RvFileCache();
t.FileStatusClear(FileStatus.CacheToSort);
_clickedTree.FileStatusSet(FileStatus.CacheToSort);
DB.Write();
DirTree.Refresh();
}
private void ChkBoxShowCorrectCheckedChanged(object sender, EventArgs e)
{
if (Settings.rvSettings.chkBoxShowCorrect != this.chkBoxShowCorrect.Checked)
{
Settings.rvSettings.chkBoxShowCorrect = this.chkBoxShowCorrect.Checked;
Settings.WriteConfig(Settings.rvSettings);
DatSetSelected(DirTree.Selected);
}
}
private void ChkBoxShowMissingCheckedChanged(object sender, EventArgs e)
{
if (Settings.rvSettings.chkBoxShowMissing != this.chkBoxShowMissing.Checked)
{
Settings.rvSettings.chkBoxShowMissing = this.chkBoxShowMissing.Checked;
Settings.WriteConfig(Settings.rvSettings);
DatSetSelected(DirTree.Selected);
}
}
private void ChkBoxShowFixedCheckedChanged(object sender, EventArgs e)
{
if (Settings.rvSettings.chkBoxShowFixed != this.chkBoxShowFixed.Checked)
{
Settings.rvSettings.chkBoxShowFixed = this.chkBoxShowFixed.Checked;
Settings.WriteConfig(Settings.rvSettings);
DatSetSelected(DirTree.Selected);
}
}
private void ChkBoxShowMergedCheckedChanged(object sender, EventArgs e)
{
if (Settings.rvSettings.chkBoxShowMerged != this.chkBoxShowMerged.Checked)
{
Settings.rvSettings.chkBoxShowMerged = this.chkBoxShowMerged.Checked;
Settings.WriteConfig(Settings.rvSettings);
UpdateSelectedGame();
}
}
private void btnReport_MouseUp(object sender, MouseEventArgs e)
{
Report.MakeFixFiles(null, e.Button == MouseButtons.Left);
}
private void fixDatReportToolStripMenuItem_Click(object sender, EventArgs e)
{
Report.MakeFixFiles();
}
private void fullReportToolStripMenuItem_Click(object sender, EventArgs e)
{
Report.GenerateReport();
}
private void fixReportToolStripMenuItem_Click(object sender, EventArgs e)
{
Report.GenerateFixReport();
}
private void AboutRomVaultToolStripMenuItemClick(object sender, EventArgs e)
{
FrmHelpAbout fha = new FrmHelpAbout();
fha.ShowDialog(this);
fha.Dispose();
}
#region "Main Buttons"
private void TsmUpdateDaTsClick(object sender, EventArgs e)
{
UpdateDats();
}
private void btnUpdateDats_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right && Control.ModifierKeys == Keys.Shift)
{
DatUpdate.CheckAllDats(DB.DirTree.Child(0), @"DatRoot\");
}
UpdateDats();
}
private void UpdateDats()
{
FrmProgressWindow progress = new FrmProgressWindow(this, "Scanning Dats", DatUpdate.UpdateDat);
progress.ShowDialog(this);
progress.Dispose();
DirTree.Setup(ref DB.DirTree);
DatSetSelected(DirTree.Selected);
}
private void TsmScanLevel1Click(object sender, EventArgs e)
{
ScanRoms(EScanLevel.Level1);
}
private void TsmScanLevel2Click(object sender, EventArgs e)
{
ScanRoms(EScanLevel.Level2);
}
private void TsmScanLevel3Click(object sender, EventArgs e)
{
ScanRoms(EScanLevel.Level3);
}
private void BtnScanRomsClick(object sender, EventArgs e)
{
ScanRoms(Settings.rvSettings.ScanLevel);
}
private void ScanRoms(EScanLevel sd, RvFile StartAt = null)
{
FileScanning.StartAt = StartAt;
FileScanning.EScanLevel = sd;
FrmProgressWindow progress = new FrmProgressWindow(this, "Scanning Dirs", FileScanning.ScanFiles);
progress.ShowDialog(this);
progress.Dispose();
DatSetSelected(DirTree.Selected);
}
private void TsmFindFixesClick(object sender, EventArgs e)
{
FindFix();
}
private void BtnFindFixesClick(object sender, EventArgs e)
{
FindFix();
}
private void FindFix()
{
FrmProgressWindow progress = new FrmProgressWindow(this, "Finding Fixes", FindFixes.ScanFiles);
progress.ShowDialog(this);
progress.Dispose();
DatSetSelected(DirTree.Selected);
}
private void btnFixFiles_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
ScanRoms(Settings.rvSettings.ScanLevel);
FindFix();
}
FixFiles();
}
private void FixFilesToolStripMenuItemClick(object sender, EventArgs e)
{
FixFiles();
}
private void FixFiles()
{
FrmProgressWindowFix progress = new FrmProgressWindowFix(this);
progress.ShowDialog(this);
progress.Dispose();
DatSetSelected(DirTree.Selected);
}
#endregion
#region "DAT display code"
private void DatSetSelected(RvFile cf)
{
DirTree.Refresh();
ClearGameGrid();
if (cf == null)
{
return;
}
UpdateDatMetaData(cf);
UpdateGameGrid(cf);
}
private void splitContainer3_Panel1_Resize(object sender, EventArgs e)
{
// fixes a rendering issue in mono
if (splitDatInfoTree.Panel1.Width == 0)
{
return;
}
gbDatInfo.Width = splitDatInfoTree.Panel1.Width - gbDatInfo.Left * 2;
}
private void splitContainer4_Panel1_Resize(object sender, EventArgs e)
{
// fixes a rendering issue in mono
if (splitGameInfoLists.Panel1.Width == 0)
{
return;
}
int chkLeft = splitGameInfoLists.Panel1.Width - 150;
if (chkLeft < 430)
{
chkLeft = 430;
}
chkBoxShowCorrect.Left = chkLeft;
chkBoxShowMissing.Left = chkLeft;
chkBoxShowFixed.Left = chkLeft;
chkBoxShowMerged.Left = chkLeft;
txtFilter.Left = chkLeft;
btnClear.Left = chkLeft + txtFilter.Width + 2;
picPayPal.Left = chkLeft;
picPatreon.Left = chkLeft + picPayPal.Width;
gbSetInfo.Width = chkLeft - gbSetInfo.Left - 10;
}
private void gbDatInfo_Resize(object sender, EventArgs e)
{
const int leftPos = 89;
int rightPos = (int)(gbDatInfo.Width / _scaleFactorX) - 15;
int width = rightPos - leftPos;
int widthB1 = (int)((double)width * 120 / 340);
int leftB2 = rightPos - widthB1;
int backD = 97;
width = (int)(width * _scaleFactorX);
widthB1 = (int)(widthB1 * _scaleFactorX);
leftB2 = (int)(leftB2 * _scaleFactorX);
backD = (int)(backD * _scaleFactorX);
lblDITName.Width = width;
lblDITDescription.Width = width;
lblDITCategory.Width = widthB1;
lblDITAuthor.Width = widthB1;
lblDIVersion.Left = leftB2 - backD;
lblDIDate.Left = leftB2 - backD;
lblDITVersion.Left = leftB2;
lblDITVersion.Width = widthB1;
lblDITDate.Left = leftB2;
lblDITDate.Width = widthB1;
lblDITPath.Width = width;
lblDITRomsGot.Width = widthB1;
lblDITRomsMissing.Width = widthB1;
lblDIRomsFixable.Left = leftB2 - backD;
lblDIRomsUnknown.Left = leftB2 - backD;
lblDITRomsFixable.Left = leftB2;
lblDITRomsFixable.Width = widthB1;
lblDITRomsUnknown.Left = leftB2;
lblDITRomsUnknown.Width = widthB1;
}
private void UpdateDatMetaData(RvFile tDir)
{
lblDITName.Text = tDir.Name;
if (tDir.Dat != null)
{
RvDat tDat = tDir.Dat;
lblDITDescription.Text = tDat.GetData(RvDat.DatData.Description);
lblDITCategory.Text = tDat.GetData(RvDat.DatData.Category);
lblDITVersion.Text = tDat.GetData(RvDat.DatData.Version);
lblDITAuthor.Text = tDat.GetData(RvDat.DatData.Author);
lblDITDate.Text = tDat.GetData(RvDat.DatData.Date);
string header = tDat.GetData(RvDat.DatData.Header);
if (!string.IsNullOrWhiteSpace(header))
lblDITName.Text += " (" + header + ")";
}
else if (tDir.DirDatCount == 1)
{
RvDat tDat = tDir.DirDat(0);
lblDITDescription.Text = tDat.GetData(RvDat.DatData.Description);
lblDITCategory.Text = tDat.GetData(RvDat.DatData.Category);
lblDITVersion.Text = tDat.GetData(RvDat.DatData.Version);
lblDITAuthor.Text = tDat.GetData(RvDat.DatData.Author);
lblDITDate.Text = tDat.GetData(RvDat.DatData.Date);
string header = tDat.GetData(RvDat.DatData.Header);
if (!string.IsNullOrWhiteSpace(header))
lblDITName.Text += " (" + header + ")";
}
else
{
lblDITDescription.Text = "";
lblDITCategory.Text = "";
lblDITVersion.Text = "";
lblDITAuthor.Text = "";
lblDITDate.Text = "";
}
lblDITPath.Text = tDir.FullName;
lblDITRomsGot.Text = tDir.DirStatus.CountCorrect().ToString(CultureInfo.InvariantCulture);
lblDITRomsMissing.Text = tDir.DirStatus.CountMissing().ToString(CultureInfo.InvariantCulture);
lblDITRomsFixable.Text = tDir.DirStatus.CountFixesNeeded().ToString(CultureInfo.InvariantCulture);
lblDITRomsUnknown.Text = (tDir.DirStatus.CountUnknown() + tDir.DirStatus.CountInToSort()).ToString(CultureInfo.InvariantCulture);
}
#endregion
private void picPayPal_Click(object sender, EventArgs e)
{
Process.Start("http://paypal.me/romvault");
}
private void picPatreon_Click(object sender, EventArgs e)
{
Process.Start("https://www.patreon.com/romvault");
}
/*
private void jsonDataDumpToolStripMenuItem_Click(object sender, EventArgs e)
{
DB.WriteJson();
}
*/
private void colorKeyToolStripMenuItem_Click(object sender, EventArgs e)
{
if (_fk == null || _fk.IsDisposed)
{
_fk = new FrmKey();
}
_fk.Show();
}
private void BtnClear_Click(object sender, EventArgs e)
{
txtFilter.Text = "";
}
private void TxtFilter_TextChanged(object sender, EventArgs e)
{
if (gameGridSource != null)
UpdateGameGrid(gameGridSource);
txtFilter.Focus();
}
private void RomVaultSettingsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (FrmSettings fcfg = new FrmSettings())
{
fcfg.ShowDialog(this);
}
}
private void RegistrationSettingsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (FrmRegistration fReg = new FrmRegistration())
{
fReg.ShowDialog();
}
}
private void DirectorySettingsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (FrmSetDirSettings sd = new FrmSetDirSettings())
{
string tDir = "RomVault";
sd.SetLocation(tDir);
sd.SetDisplayType(false);
sd.ShowDialog(this);
if (sd.ChangesMade)
UpdateDats();
}
}
}
} | 32.26674 | 141 | 0.553904 | [
"Apache-2.0"
] | mnadareski/RVWorld | ROMVault/FrmMain.cs | 29,395 | C# |
using Uv2ray.ViewModels;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Navigation;
namespace Uv2ray.Views
{
// TODO WTS: Change the URL for your privacy policy in the Resource File, currently set to https://YourPrivacyUrlGoesHere
public sealed partial class SettingsPage : Page
{
public SettingsViewModel ViewModel { get; } = new SettingsViewModel();
public SettingsPage()
{
InitializeComponent();
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
await ViewModel.InitializeAsync();
}
}
}
| 25.791667 | 125 | 0.66559 | [
"MIT"
] | AngelBeats-Kanade/Uv2ray | Uv2ray/Uv2ray/Views/SettingsPage.xaml.cs | 621 | C# |
//-----------------------------------------------------------------------------
// FILE: WorkflowFutureReadyReply.cs
// CONTRIBUTOR: Jeff Lill
// COPYRIGHT: Copyright (c) 2005-2022 by neonFORGE LLC. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using Neon.Cadence;
using Neon.Common;
namespace Neon.Cadence.Internal
{
/// <summary>
/// <para>
/// <b>proxy --> client:</b> This is a special reply message sent for workflow operations that
/// are implemented in GOLANG as futures and may be executed in parallel. <b>cadence-proxy</b>
/// will send this message after it has submitted the operation to Cadence but before the future
/// actually completes. The .NET client uses this reply as an indication that another Cadence
/// operation may be started.
/// </para>
/// <note>
/// This message does not have a corresponding request message (which is why the name doesn't end with "Reply".
/// </note>
/// </summary>
[InternalProxyMessage(InternalMessageTypes.WorkflowFutureReadyReply)]
internal class WorkflowFutureReadyReply : WorkflowReply
{
/// <summary>
/// Default constructor.
/// </summary>
public WorkflowFutureReadyReply()
{
Type = InternalMessageTypes.WorkflowFutureReadyReply;
}
/// <inheritdoc/>
internal override ProxyMessage Clone()
{
var clone = new WorkflowFutureReadyReply();
CopyTo(clone);
return clone;
}
/// <inheritdoc/>
protected override void CopyTo(ProxyMessage target)
{
base.CopyTo(target);
}
}
}
| 34.089552 | 115 | 0.642732 | [
"Apache-2.0"
] | codelastnight/neonKUBE | Lib/Neon.Cadence/Internal/WorkflowMessages/WorkflowFutureReadyReply.cs | 2,286 | C# |
using System;
using System.Data;
namespace SelectStar
{
public class SelectStarDbAccess
{
public SelectStarDbAccess ()
{
}
public static SelectStarDbAccess CreateSelectStarDbAccess(SelectStarDbAccessKind kind)
{
switch (kind)
{
case SelectStarDbAccessKind.Npgsql:
return new SelectStarDbAccessPostgre();
case SelectStarDbAccessKind.Mysql:
return new SelectStarDbAccessMySql();
}
return null;
}
public virtual void OpenConnection()
{
throw new NotImplementedException("OpenConnection");
}
public virtual System.Data.IDbConnection GetConnection()
{
throw new NotImplementedException("GetConnection");
}
public virtual int ExecuteCommand(string sql)
{
int ra = -1;
using (var cmd = GetConnection().CreateCommand())
{
cmd.CommandText = sql;
ra = cmd.ExecuteNonQuery();
}
return ra;
}
public virtual void DropTable(string TableName)
{
var sql = string.Format("drop table if exists {0}", TableName);
ExecuteCommand(sql);
}
public virtual IDbDataAdapter GetDataAdapterForSQL(string sql)
{
throw new NotImplementedException("GetDataAdapterForSQL");
}
public virtual void PerformSelectStar(string TableName)
{
try
{
var sql = "select * from " + TableName;
var dataAdapter = GetDataAdapterForSQL(sql);
var dataSet = new DataSet();
dataAdapter.Fill(dataSet);
var columns = "";
foreach (DataColumn column in dataSet.Tables[0].Columns)
{
columns += column.ColumnName + " ";
}
Console.WriteLine("Columns: " + columns);
}
catch (Exception ex)
{
Console.WriteLine("PerformSelectStar: " + ex.Message);
}
}
public enum SelectStarDbAccessKind
{
Npgsql,
Mysql
}
}
}
| 20.541176 | 88 | 0.686712 | [
"MIT"
] | MichaelKremser/selectstar | SelectStarDbAccess.cs | 1,746 | C# |
//------------------------------------------------------------------------------
// <auto-generated />
// This file was automatically generated by the UpdateVendors tool.
//------------------------------------------------------------------------------
#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, SYSLIB0011,SYSLIB0032
// dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using Datadog.Trace.Vendors.dnlib.DotNet.MD;
using Datadog.Trace.Vendors.dnlib.DotNet.Pdb;
namespace Datadog.Trace.Vendors.dnlib.DotNet {
/// <summary>
/// A high-level representation of a row in the ManifestResource table
/// </summary>
[DebuggerDisplay("{Offset} {Name.String} {Implementation}")]
internal abstract class ManifestResource : IHasCustomAttribute, IHasCustomDebugInformation {
/// <summary>
/// The row id in its table
/// </summary>
protected uint rid;
/// <inheritdoc/>
public MDToken MDToken => new MDToken(Table.ManifestResource, rid);
/// <inheritdoc/>
public uint Rid {
get => rid;
set => rid = value;
}
/// <inheritdoc/>
public int HasCustomAttributeTag => 18;
/// <summary>
/// From column ManifestResource.Offset
/// </summary>
public uint Offset {
get => offset;
set => offset = value;
}
/// <summary/>
protected uint offset;
/// <summary>
/// From column ManifestResource.Flags
/// </summary>
public ManifestResourceAttributes Flags {
get => (ManifestResourceAttributes)attributes;
set => attributes = (int)value;
}
/// <summary>Attributes</summary>
protected int attributes;
/// <summary>
/// From column ManifestResource.Name
/// </summary>
public UTF8String Name {
get => name;
set => name = value;
}
/// <summary>Name</summary>
protected UTF8String name;
/// <summary>
/// From column ManifestResource.Implementation
/// </summary>
public IImplementation Implementation {
get => implementation;
set => implementation = value;
}
/// <summary/>
protected IImplementation implementation;
/// <summary>
/// Gets all custom attributes
/// </summary>
public CustomAttributeCollection CustomAttributes {
get {
if (customAttributes is null)
InitializeCustomAttributes();
return customAttributes;
}
}
/// <summary/>
protected CustomAttributeCollection customAttributes;
/// <summary>Initializes <see cref="customAttributes"/></summary>
protected virtual void InitializeCustomAttributes() =>
Interlocked.CompareExchange(ref customAttributes, new CustomAttributeCollection(), null);
/// <inheritdoc/>
public bool HasCustomAttributes => CustomAttributes.Count > 0;
/// <inheritdoc/>
public int HasCustomDebugInformationTag => 18;
/// <inheritdoc/>
public bool HasCustomDebugInfos => CustomDebugInfos.Count > 0;
/// <summary>
/// Gets all custom debug infos
/// </summary>
public IList<PdbCustomDebugInfo> CustomDebugInfos {
get {
if (customDebugInfos is null)
InitializeCustomDebugInfos();
return customDebugInfos;
}
}
/// <summary/>
protected IList<PdbCustomDebugInfo> customDebugInfos;
/// <summary>Initializes <see cref="customDebugInfos"/></summary>
protected virtual void InitializeCustomDebugInfos() =>
Interlocked.CompareExchange(ref customDebugInfos, new List<PdbCustomDebugInfo>(), null);
/// <summary>
/// Modify <see cref="attributes"/> property: <see cref="attributes"/> =
/// (<see cref="attributes"/> & <paramref name="andMask"/>) | <paramref name="orMask"/>.
/// </summary>
/// <param name="andMask">Value to <c>AND</c></param>
/// <param name="orMask">Value to OR</param>
void ModifyAttributes(ManifestResourceAttributes andMask, ManifestResourceAttributes orMask) =>
attributes = (attributes & (int)andMask) | (int)orMask;
/// <summary>
/// Gets/sets the visibility
/// </summary>
public ManifestResourceAttributes Visibility {
get => (ManifestResourceAttributes)attributes & ManifestResourceAttributes.VisibilityMask;
set => ModifyAttributes(~ManifestResourceAttributes.VisibilityMask, value & ManifestResourceAttributes.VisibilityMask);
}
/// <summary>
/// <c>true</c> if <see cref="ManifestResourceAttributes.Public"/> is set
/// </summary>
public bool IsPublic => ((ManifestResourceAttributes)attributes & ManifestResourceAttributes.VisibilityMask) == ManifestResourceAttributes.Public;
/// <summary>
/// <c>true</c> if <see cref="ManifestResourceAttributes.Private"/> is set
/// </summary>
public bool IsPrivate => ((ManifestResourceAttributes)attributes & ManifestResourceAttributes.VisibilityMask) == ManifestResourceAttributes.Private;
}
/// <summary>
/// A ManifestResource row created by the user and not present in the original .NET file
/// </summary>
internal class ManifestResourceUser : ManifestResource {
/// <summary>
/// Default constructor
/// </summary>
public ManifestResourceUser() {
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="implementation">Implementation</param>
public ManifestResourceUser(UTF8String name, IImplementation implementation)
: this(name, implementation, 0) {
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="implementation">Implementation</param>
/// <param name="flags">Flags</param>
public ManifestResourceUser(UTF8String name, IImplementation implementation, ManifestResourceAttributes flags)
: this(name, implementation, flags, 0) {
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="implementation">Implementation</param>
/// <param name="flags">Flags</param>
/// <param name="offset">Offset</param>
public ManifestResourceUser(UTF8String name, IImplementation implementation, ManifestResourceAttributes flags, uint offset) {
this.name = name;
this.implementation = implementation;
attributes = (int)flags;
this.offset = offset;
}
}
/// <summary>
/// Created from a row in the ManifestResource table
/// </summary>
sealed class ManifestResourceMD : ManifestResource, IMDTokenProviderMD {
/// <summary>The module where this instance is located</summary>
readonly ModuleDefMD readerModule;
readonly uint origRid;
/// <inheritdoc/>
public uint OrigRid => origRid;
/// <inheritdoc/>
protected override void InitializeCustomAttributes() {
var list = readerModule.Metadata.GetCustomAttributeRidList(Table.ManifestResource, origRid);
var tmp = new CustomAttributeCollection(list.Count, list, (list2, index) => readerModule.ReadCustomAttribute(list[index]));
Interlocked.CompareExchange(ref customAttributes, tmp, null);
}
/// <inheritdoc/>
protected override void InitializeCustomDebugInfos() {
var list = new List<PdbCustomDebugInfo>();
readerModule.InitializeCustomDebugInfos(new MDToken(MDToken.Table, origRid), new GenericParamContext(), list);
Interlocked.CompareExchange(ref customDebugInfos, list, null);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="readerModule">The module which contains this <c>ManifestResource</c> row</param>
/// <param name="rid">Row ID</param>
/// <exception cref="ArgumentNullException">If <paramref name="readerModule"/> is <c>null</c></exception>
/// <exception cref="ArgumentException">If <paramref name="rid"/> is invalid</exception>
public ManifestResourceMD(ModuleDefMD readerModule, uint rid) {
#if DEBUG
if (readerModule is null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.ManifestResourceTable.IsInvalidRID(rid))
throw new BadImageFormatException($"ManifestResource rid {rid} does not exist");
#endif
origRid = rid;
this.rid = rid;
this.readerModule = readerModule;
bool b = readerModule.TablesStream.TryReadManifestResourceRow(origRid, out var row);
Debug.Assert(b);
offset = row.Offset;
attributes = (int)row.Flags;
name = readerModule.StringsStream.ReadNoNull(row.Name);
implementation = readerModule.ResolveImplementation(row.Implementation);
}
}
}
| 33.888889 | 150 | 0.698239 | [
"Apache-2.0"
] | DataDog/dd-trace-csharp | tracer/src/Datadog.Trace/Vendors/dnlib/DotNet/ManifestResource.cs | 8,235 | C# |
using System;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK.Input;
namespace OpenTkEssTest
{
//[Example("VBO Dynamic", ExampleCategory.OpenGL, "1.x", 4, Documentation = "VBODynamic")]
class T09_VBO_Dynamic : GameWindow
{
/// <summary>Creates a 800x600 window with the specified title.</summary>
public T09_VBO_Dynamic()
: base(800, 600)
{
this.VSync = VSyncMode.Off;
}
#region Particles
static int MaxParticleCount = 2000;
int VisibleParticleCount;
VertexC4ubV3f[] VBO = new VertexC4ubV3f[MaxParticleCount];
ParticleAttribut[] ParticleAttributes = new ParticleAttribut[MaxParticleCount];
// this struct is used for drawing
struct VertexC4ubV3f
{
public byte R, G, B, A;
public Vector3 Position;
public static int SizeInBytes = 16;
}
// this struct is used for updates
struct ParticleAttribut
{
public Vector3 Direction;
public uint Age;
// more stuff could be here: Rotation, Radius, whatever
}
uint VBOHandle;
#endregion Particles
/// <summary>Load resources here.</summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
GL.ClearColor(.1f, 0f, .1f, 0f);
//GL.Enable(EnableCap.DepthTest);
// Setup parameters for Points
GL.PointSize(1f);
//GL.Enable(EnableCap.PointSmooth);
//GL.Hint(HintTarget.PointSmoothHint, HintMode.Nicest);
// Setup VBO state
GL.EnableClientState(ArrayCap.ColorArray);
GL.EnableClientState(ArrayCap.VertexArray);
GL.GenBuffers(1, out VBOHandle);
// Since there's only 1 VBO in the app, might aswell setup here.
GL.BindBuffer(BufferTarget.ArrayBuffer, VBOHandle);
GL.ColorPointer(4, ColorPointerType.UnsignedByte, VertexC4ubV3f.SizeInBytes, (IntPtr)0);
GL.VertexPointer(3, VertexPointerType.Float, VertexC4ubV3f.SizeInBytes, (IntPtr)(4 * sizeof(byte)));
Random rnd = new Random();
Vector3 temp = Vector3.Zero;
// generate some random stuff for the particle system
for (uint i = 0; i < MaxParticleCount; i++)
{
VBO[i].R = (byte)rnd.Next(0, 256);
VBO[i].G = (byte)rnd.Next(0, 256);
VBO[i].B = (byte)rnd.Next(0, 256);
VBO[i].A = (byte)rnd.Next(0, 256); // isn't actually used
VBO[i].Position = Vector3.Zero; // all particles are born at the origin
// generate direction vector in the range [-0.25f...+0.25f]
// that's slow enough so you can see particles 'disappear' when they are respawned
temp.X = (float)((rnd.NextDouble() - 0.5) * 0.5f);
temp.Y = (float)((rnd.NextDouble() - 0.5) * 0.5f);
temp.Z = (float)((rnd.NextDouble() - 0.5) * 0.5f);
ParticleAttributes[i].Direction = temp; // copy
ParticleAttributes[i].Age = 0;
}
VisibleParticleCount = 0;
}
protected override void OnUnload(EventArgs e)
{
GL.DeleteBuffers(1, ref VBOHandle);
}
/// <summary>
/// Called when your window is resized. Set your viewport here. It is also
/// a good place to set up your projection matrix (which probably changes
/// along when the aspect ratio of your window).
/// </summary>
/// <param name="e">Contains information on the new Width and Size of the GameWindow.</param>
protected override void OnResize(EventArgs e)
{
GL.Viewport(0, 0, Width, Height);
GL.MatrixMode(MatrixMode.Projection);
Matrix4 p = Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver4, Width / (float)Height, 0.1f, 50.0f);
GL.LoadMatrix(ref p);
GL.MatrixMode(MatrixMode.Modelview);
Matrix4 mv = Matrix4.LookAt(Vector3.UnitZ, Vector3.Zero, Vector3.UnitY);
GL.LoadMatrix(ref mv);
}
/// <summary>
/// Called when it is time to setup the next frame. Add you game logic here.
/// </summary>
/// <param name="e">Contains timing information for framerate independent logic.</param>
protected override void OnUpdateFrame(FrameEventArgs e)
{
if (Keyboard[Key.Escape])
{
Exit();
}
// will update particles here. When using a Physics SDK, it's update rate is much higher than
// the framerate and it would be a waste of cycles copying to the VBO more often than drawing it.
if (VisibleParticleCount < MaxParticleCount)
VisibleParticleCount++;
Vector3 temp;
for (int i = MaxParticleCount - VisibleParticleCount; i < MaxParticleCount; i++)
{
if (ParticleAttributes[i].Age >= MaxParticleCount)
{
// reset particle
ParticleAttributes[i].Age = 0;
VBO[i].Position = Vector3.Zero;
}
else
{
ParticleAttributes[i].Age += (uint)Math.Max(ParticleAttributes[i].Direction.LengthFast * 10, 1);
Vector3.Multiply(ref ParticleAttributes[i].Direction, (float)e.Time, out temp);
Vector3.Add(ref VBO[i].Position, ref temp, out VBO[i].Position);
}
}
}
/// <summary>
/// Called when it is time to render the next frame. Add your rendering code here.
/// </summary>
/// <param name="e">Contains timing information.</param>
protected override void OnRenderFrame(FrameEventArgs e)
{
this.Title = VisibleParticleCount + " Points. FPS: " + string.Format("{0:F}", 1.0 / e.Time);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.PushMatrix();
GL.Translate(0f, 0f, -5f);
// Tell OpenGL to discard old VBO when done drawing it and reserve memory _now_ for a new buffer.
// without this, GL would wait until draw operations on old VBO are complete before writing to it
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(VertexC4ubV3f.SizeInBytes * MaxParticleCount), IntPtr.Zero, BufferUsageHint.StreamDraw);
// Fill newly allocated buffer
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(VertexC4ubV3f.SizeInBytes * MaxParticleCount), VBO, BufferUsageHint.StreamDraw);
// Only draw particles that are alive
GL.DrawArrays(BeginMode.Points, MaxParticleCount - VisibleParticleCount, VisibleParticleCount);
GL.PopMatrix();
SwapBuffers();
}
}
} | 39.18232 | 149 | 0.579385 | [
"MIT"
] | PaintLab/PixelFarm.External | src/MiniOpenTk/OpenTkEssTest/02_VertextBuffer/VBODynamic.cs | 7,094 | C# |
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Cookbook.Entities;
namespace Cookbook.Repositories
{
public interface IItemsRepository
{
Task<Item> GetItemAsync(Guid id);
Task<IEnumerable<Item>> GetItemsAsync();
Task CreateItemAsync(Item item);
Task UpdateItemAsync(Item item);
Task DeleteItemAsync(Guid id);
}
} | 23.647059 | 48 | 0.70398 | [
"MIT"
] | shaneconwell/cookbook-api | Repositories/IItemsRepository.cs | 402 | C# |
// -----------------------------------------------------------------------------------
//
// GRABCASTER LTD CONFIDENTIAL
// ___________________________
//
// Copyright © 2013 - 2016 GrabCaster Ltd. All rights reserved.
// This work is registered with the UK Copyright Service: Registration No:284701085
//
//
// NOTICE: All information contained herein is, and remains
// the property of GrabCaster Ltd and its suppliers,
// if any. The intellectual and technical concepts contained
// herein are proprietary to GrabCaster Ltd
// and its suppliers and may be covered by UK and Foreign Patents,
// patents in process, and are protected by trade secret or copyright law.
// Dissemination of this information or reproduction of this material
// is strictly forbidden unless prior written permission is obtained
// from GrabCaster Ltd.
//
// -----------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace GrabCaster.Framework.Contracts.Messaging
{
using System.Runtime.Serialization;
[Serializable]
public class SkeletonMessage: ISkeletonMessage
{
/// <summary>
/// Gets or sets the properties.
/// </summary>
public IDictionary<string, object> Properties { get; set; }
/// <summary>
/// Gets or sets the body.
/// </summary>
public byte[] Body { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="SkeletonMessage"/> class.
/// </summary>
/// <param name="body">
/// The body.
/// </param>
public SkeletonMessage(byte[] body)
{
Properties = new Dictionary<string, object>();
Body = body;
}
/// <summary>
/// The serialize message.
/// </summary>
/// <returns>
/// The <see cref="byte[]"/>.
/// </returns>
public static byte[] SerializeMessage(SkeletonMessage skeletonMessage)
{
return GrabCaster.Framework.Serialization.Object.SerializationEngine.ObjectToByteArray(skeletonMessage);
}
/// <summary>
/// The serialize message.
/// </summary>
/// <returns>
/// The <see cref="byte[]"/>.
/// </returns>
public static SkeletonMessage DeserializeMessage(byte[] byteArray)
{
return (SkeletonMessage) GrabCaster.Framework.Serialization.Object.SerializationEngine.ByteArrayToObject(byteArray);
}
}
}
| 32.775 | 128 | 0.589626 | [
"MIT"
] | debiaggi/GrabCaster | Framework.Contracts/Messaging/SkeletonMessage.cs | 2,625 | C# |
using System.ComponentModel;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Scripting;
#if UNITY_EDITOR
using UnityEngine.InputSystem.Editor;
#endif
namespace UnityEngine.InputSystem.Interactions
{
/// <summary>
/// Performs the action if the control is pressed held for at least the set
/// duration (which defaults to <see cref="InputSettings.defaultTapTime"/>)
/// and then released.
/// </summary>
[DisplayName("Tap")]
public class TapInteraction : IInputInteraction
{
////REVIEW: this should be called tapTime
/// <summary>
/// The time in seconds within which the control needs to be pressed and released to perform the interaction.
/// </summary>
/// <remarks>
/// If this value is equal to or smaller than zero, the input system will use (<see cref="InputSettings.defaultTapTime"/>) instead.
/// </remarks>
public float duration;
/// <summary>
/// The press point required to perform the interaction.
/// </summary>
/// <remarks>
/// For analog controls (such as trigger axes on a gamepad), the control needs to be engaged by at least this
/// value to perform the interaction.
/// If this value is equal to or smaller than zero, the input system will use (<see cref="InputSettings.defaultButtonPressPoint"/>) instead.
/// </remarks>
public float pressPoint;
private float durationOrDefault => duration > 0.0 ? duration : InputSystem.settings.defaultTapTime;
private float pressPointOrDefault => pressPoint > 0 ? pressPoint : ButtonControl.s_GlobalDefaultButtonPressPoint;
private float releasePointOrDefault => pressPointOrDefault * ButtonControl.s_GlobalDefaultButtonReleaseThreshold;
private double m_TapStartTime;
////TODO: make sure 2d doesn't move too far
public void Process(ref InputInteractionContext context)
{
if (context.timerHasExpired)
{
context.Canceled();
return;
}
if (context.isWaiting && context.ControlIsActuated(pressPointOrDefault))
{
m_TapStartTime = context.time;
// Set timeout slightly after duration so that if tap comes in exactly at the expiration
// time, it still counts as a valid tap.
context.Started();
context.SetTimeout(durationOrDefault + 0.00001f);
return;
}
if (context.isStarted && !context.ControlIsActuated(releasePointOrDefault))
{
if (context.time - m_TapStartTime <= durationOrDefault)
{
context.Performed();
}
else
{
////REVIEW: does it matter to cancel right after expiration of 'duration' or is it enough to cancel on button up like here?
context.Canceled();
}
}
}
public void Reset()
{
m_TapStartTime = 0;
}
}
#if UNITY_EDITOR
internal class TapInteractionEditor : InputParameterEditor<TapInteraction>
{
protected override void OnEnable()
{
m_DurationSetting.Initialize("Max Tap Duration",
"Time (in seconds) within with a control has to be released again for it to register as a tap. If the control is held "
+ "for longer than this time, the tap is canceled.",
"Default Tap Time",
() => target.duration, x => target.duration = x, () => InputSystem.settings.defaultTapTime);
m_PressPointSetting.Initialize("Press Point",
"The amount of actuation a control requires before being considered pressed. If not set, default to "
+ "'Default Button Press Point' in the global input settings.",
"Default Button Press Point",
() => target.pressPoint, v => target.pressPoint = v,
() => InputSystem.settings.defaultButtonPressPoint);
}
public override void OnGUI()
{
m_DurationSetting.OnGUI();
m_PressPointSetting.OnGUI();
}
private CustomOrDefaultSetting m_DurationSetting;
private CustomOrDefaultSetting m_PressPointSetting;
}
#endif
}
| 39.714286 | 148 | 0.604092 | [
"Apache-2.0"
] | AhmadAlrifa1/Shooter-Game | Library/PackageCache/[email protected]/InputSystem/Actions/Interactions/TapInteraction.cs | 4,448 | C# |
using Engine.Tween;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
namespace Engine.PostProcessing.Tween
{
/// <summary>
/// Tween collection for post processing parameters
/// </summary>
class DrawerPostProcessParamsTweenCollection : ITweenCollection<IDrawerPostProcessParams>
{
/// <summary>
/// Task list
/// </summary>
private readonly ConcurrentDictionary<IDrawerPostProcessParams, List<Func<float, bool>>> tasks = new ConcurrentDictionary<IDrawerPostProcessParams, List<Func<float, bool>>>();
/// <summary>
/// Updates the task list
/// </summary>
/// <param name="gameTime">Game time</param>
public void Update(GameTime gameTime)
{
if (!tasks.Any())
{
return;
}
// Copy active controls
var activeControls = tasks.ToArray();
foreach (var task in activeControls)
{
if (!task.Key.Active)
{
continue;
}
// Copy active tasks
var activeTasks = task.Value.ToList();
if (!activeTasks.Any())
{
continue;
}
List<Func<float, bool>> toDelete = new List<Func<float, bool>>();
activeTasks.ForEach(t =>
{
bool finished = t.Invoke(gameTime.ElapsedSeconds);
if (finished)
{
toDelete.Add(t);
}
});
if (toDelete.Any())
{
toDelete.ForEach(t => task.Value.Remove(t));
}
}
var emptyControls = tasks.Where(t => t.Value.Count == 0).Select(t => t.Key).ToList();
if (emptyControls.Any())
{
emptyControls.ForEach(c => tasks.TryRemove(c, out _));
}
}
/// <summary>
/// Adds a new tween to the specified item
/// </summary>
/// <param name="item">Tween item</param>
/// <param name="tween">Tween funcion</param>
public void AddTween(IDrawerPostProcessParams item, Func<float, bool> tween)
{
var list = tasks.GetOrAdd(item, new List<Func<float, bool>>());
list.Add(tween);
}
/// <summary>
/// Clears all tweens
/// </summary>
/// <param name="item">Tween item</param>
public void ClearTween(IDrawerPostProcessParams item)
{
tasks.TryRemove(item, out _);
}
/// <summary>
/// Clears all the tween tasks
/// </summary>
public void Clear()
{
tasks.Clear();
}
}
}
| 29.424242 | 183 | 0.48644 | [
"MIT"
] | Selinux24/SharpDX-Tests | Engine/PostProcessing/Tween/DrawerPostProcessParamsTweenCollection.cs | 2,915 | C# |
using ProtoBuf;
using System;
using System.Collections.Generic;
namespace GameData
{
[ProtoContract(Name = "DiaoLuoZu_ARRAY")]
[Serializable]
public class DiaoLuoZu_ARRAY : IExtensible
{
private readonly List<DiaoLuoZu> _items = new List<DiaoLuoZu>();
private IExtension extensionObject;
[ProtoMember(1, Name = "items", DataFormat = DataFormat.Default)]
public List<DiaoLuoZu> items
{
get
{
return this._items;
}
}
IExtension IExtensible.GetExtensionObject(bool createIfMissing)
{
return Extensible.GetExtensionObject(ref this.extensionObject, createIfMissing);
}
}
}
| 20.366667 | 83 | 0.741408 | [
"MIT"
] | corefan/tianqi_src | src/GameData/DiaoLuoZu_ARRAY.cs | 611 | C# |
using NUnit.Framework;
using static Yoga.Net.YogaGlobal;
namespace Yoga.Net.Tests
{
[TestFixture]
public class YGStyleTest
{
[Test]
public void copy_style_same()
{
YogaNode node0 = YGNodeNew();
YogaNode node1 = YGNodeNew();
Assert.IsFalse(node0.IsDirty);
YGNodeCopyStyle(node0, node1);
Assert.IsFalse(node0.IsDirty);
}
[Test]
public void copy_style_modified()
{
YogaNode node0 = YGNodeNew();
Assert.IsFalse(node0.IsDirty);
Assert.AreEqual(FlexDirection.Column, YGNodeStyleGetFlexDirection(node0));
Assert.IsFalse(YGNodeStyleGetMaxHeight(node0).Unit != YogaUnit.Undefined);
YogaNode node1 = YGNodeNew();
YGNodeStyleSetFlexDirection(node1, FlexDirection.Row);
YGNodeStyleSetMaxHeight(node1, 10);
YGNodeCopyStyle(node0, node1);
Assert.IsTrue(node0.IsDirty);
Assert.AreEqual(FlexDirection.Row, YGNodeStyleGetFlexDirection(node0));
Assert.AreEqual(10, YGNodeStyleGetMaxHeight(node0).Value);
}
[Test]
public void copy_style_modified_same()
{
YogaNode node0 = YGNodeNew();
YGNodeStyleSetFlexDirection(node0, FlexDirection.Row);
YGNodeStyleSetMaxHeight(node0, 10);
YGNodeCalculateLayout(node0, YogaValue.YGUndefined, YogaValue.YGUndefined, Direction.LTR);
Assert.IsFalse(node0.IsDirty);
YogaNode node1 = YGNodeNew();
YGNodeStyleSetFlexDirection(node1, FlexDirection.Row);
YGNodeStyleSetMaxHeight(node1, 10);
YGNodeCopyStyle(node0, node1);
Assert.IsFalse(node0.IsDirty);
}
[Test]
public void initialise_flexShrink_flexGrow()
{
YogaNode node0 = YGNodeNew();
YGNodeStyleSetFlexShrink(node0, 1);
Assert.AreEqual(1, YGNodeStyleGetFlexShrink(node0));
YGNodeStyleSetFlexShrink(node0, YogaValue.YGUndefined);
YGNodeStyleSetFlexGrow(node0, 3);
Assert.AreEqual(
0,
YGNodeStyleGetFlexShrink(node0)); // Default value is Zero, if flex shrink is not defined
Assert.AreEqual(3, YGNodeStyleGetFlexGrow(node0));
YGNodeStyleSetFlexGrow(node0, YogaValue.YGUndefined);
YGNodeStyleSetFlexShrink(node0, 3);
Assert.AreEqual(
0,
YGNodeStyleGetFlexGrow(node0)); // Default value is Zero, if flex grow is not defined
Assert.AreEqual(3, YGNodeStyleGetFlexShrink(node0));
}
}
}
| 34.265823 | 105 | 0.611378 | [
"MIT"
] | NZMob/Yoga.Net | Yoga.Net.Tests/Functional/YGStyleTest.cs | 2,707 | C# |
using Bitstamp.Client.Websocket.Utils;
using Xunit;
namespace Bitstamp.Client.Websocket.Tests
{
public class BitstampAuthenticationTests
{
[Fact]
public void CreateSignature_ShouldReturnCorrectString()
{
var nonce = BitstampAuthentication.CreateAuthNonce(123456);
var payload = BitstampAuthentication.CreateAuthPayload(nonce);
var signature = BitstampAuthentication.CreateSignature(payload, "api_secret");
Assert.Equal("f6bea0776d7db5b8f74bc930f5b8d6901376874cfc433cf4b68b688d78238e74", signature);
}
}
} | 33.222222 | 104 | 0.715719 | [
"Apache-2.0"
] | ColossusFX/bitstamp-client-websocket | test/Bitstamp.Client.Websocket.Tests/BitstampAuthenticationTests.cs | 598 | C# |
/// <summary>
/// The inspector for the GA prefab.
/// </summary>
using UnityEngine;
using UnityEditor;
using System.Collections;
using System.Collections.Generic;
using System.Reflection.Emit;
using System.Reflection;
using System;
using GameAnalyticsSDK.Utilities;
using GameAnalyticsSDK.Setup;
using System.Text.RegularExpressions;
#if UNITY_2017_1_OR_NEWER
using UnityEngine.Networking;
#endif
namespace GameAnalyticsSDK.Editor
{
[CustomEditor(typeof(GameAnalyticsSDK.Setup.Settings))]
public class GA_SettingsInspector : UnityEditor.Editor
{
public const bool IsCustomPackage = false;
private const string AssetsPrependPath = IsCustomPackage ? "Packages/com.gameanalytics.sdk" : "Assets/GameAnalytics";
private GUIContent _publicKeyLabel = new GUIContent("Game Key", "Your GameAnalytics Game Key - copy/paste from the GA website.");
private GUIContent _privateKeyLabel = new GUIContent("Secret Key", "Your GameAnalytics Secret Key - copy/paste from the GA website.");
private GUIContent _emailLabel = new GUIContent("Email", "Your GameAnalytics user account email.");
private GUIContent _passwordLabel = new GUIContent("Password", "Your GameAnalytics user account password. Must be at least 8 characters in length.");
private GUIContent _organizationsLabel = new GUIContent("Org.", "Organizations tied to your GameAnalytics user account.");
private GUIContent _studiosLabel = new GUIContent("Studio", "Studios tied to your GameAnalytics user account.");
private GUIContent _gamesLabel = new GUIContent("Game", "Games tied to the selected GameAnalytics studio.");
private GUIContent _build = new GUIContent("Build", "The current version of the game. Updating the build name for each test version of the game will allow you to filter by build when viewing your data on the GA website.");
private GUIContent _infoLogEditor = new GUIContent("Info Log Editor", "Show info messages from GA in the unity editor console when submitting data.");
private GUIContent _infoLogBuild = new GUIContent("Info Log Build", "Show info messages from GA in builds (f.x. Xcode for iOS).");
private GUIContent _verboseLogBuild = new GUIContent("Verbose Log Build", "Show full info messages from GA in builds (f.x. Xcode for iOS). Noet that this option includes long JSON messages sent to the server.");
private GUIContent _useManualSessionHandling = new GUIContent("Use manual session handling", "Manually choose when to end and start a new session. Note initializing of the SDK will automatically start the first session.");
private GUIContent _useIMEI = new GUIContent("Use IMEI (android only)", "When Google Ad Id is not available try to use IMEI id as user is. REMEMBER to add READ_PHONE_STATE permission.");
#if UNITY_5_6_OR_NEWER
private GUIContent _usePlayerSettingsBunldeVersionForBuild = new GUIContent("Send Version* (Android, iOS) as build number", "The SDK will automatically fetch the version* number on Android and iOS and send it as the GameAnalytics build number.");
#else
private GUIContent _usePlayerSettingsBunldeVersionForBuild = new GUIContent("Send Build number (iOS) and Version* (Android) as build number", "The SDK will automatically fetch the build number on iOS and the version* number on Android and send it as the GameAnalytics build number.");
#endif
//private GUIContent _sendExampleToMyGame = new GUIContent("Get Example Game Data", "If enabled data collected while playing the example tutorial game will be sent to your game (using your game key and secret key). Otherwise data will be sent to a premade GA test game, to prevent it from polluting your data.");
private GUIContent _account = new GUIContent("Account", "This tab allows you to easily create a GameAnalytics account. You can also login to automatically retrieve your Game Key and Secret Key.");
private GUIContent _setup = new GUIContent("Setup", "This tab shows general options which are relevant for a wide variety of messages sent to GameAnalytics.");
private GUIContent _advanced = new GUIContent("Advanced", "This tab shows advanced and misc. options for the GameAnalytics SDK.");
private GUIContent _customDimensions01 = new GUIContent("Custom Dimensions 01", "List of custom dimensions 01.");
private GUIContent _customDimensions02 = new GUIContent("Custom Dimensions 02", "List of custom dimensions 02.");
private GUIContent _customDimensions03 = new GUIContent("Custom Dimensions 03", "List of custom dimensions 03.");
private GUIContent _resourceItemTypes = new GUIContent("Resource Item Types", "List of Resource Item Types.");
private GUIContent _resourceCurrrencies = new GUIContent("Resource Currencies", "List of Resource Currencies.");
private GUIContent _gaFpsAverage = new GUIContent("Submit Average FPS", "Submit the average frames per second.");
private GUIContent _gaFpsCritical = new GUIContent("Submit Critical FPS", "Submit a message whenever the frames per second falls below a certain threshold. The location of the Track Target will be used for critical FPS events.");
private GUIContent _gaFpsCriticalThreshold = new GUIContent("FPS <", "Frames per second threshold.");
private GUIContent _gaSubmitErrors = new GUIContent("Submit Errors", "Submit error and exception messages to the GameAnalytics server. Useful for getting relevant data when the game crashes, etc.");
private GUIContent _gaNativeErrorReporting = new GUIContent("Native error reporting (Android, iOS)", "Submit error and exception messages from native errors and exceptions to the GameAnalytics server. Useful for getting relevant data when the game crashes, etc. from native code.");
private GUIContent _gameSetupIcon;
private bool _gameSetupIconOpen = false;
private GUIContent _gameSetupIconMsg = new GUIContent("Your game and secret key will authenticate the game. Please set the build version too. All fields are required.");
private GUIContent _customDimensionsIcon;
private bool _customDimensionsIconOpen = false;
private GUIContent _customDimensionsIconMsg = new GUIContent("Define your custom dimension values below. Values that are not defined will be ignored.");
private GUIContent _resourceTypesIcon;
private bool _resourceTypesIconOpen = false;
private GUIContent _resourceTypesIconMsg = new GUIContent("Define all your resource currencies and resource item types. Values that are not defined will be ignored.");
private GUIContent _advancedSettingsIcon;
private bool _advancedSettingsIconOpen = false;
private GUIContent _advancedSettingsIconMsg = new GUIContent("Advanced settings allows you to enable tracking of Unity errors and exceptions, and frames per second (for performance).");
private GUIContent _debugSettingsIcon;
private bool _debugSettingsIconOpen = false;
private GUIContent _debugSettingsIconMsg = new GUIContent("Debug settings allows you to enable info log for the editor or for builds (Xcode, etc.). Enabling verbose logging will show additional JSON messages in builds.");
private GUIContent _deleteIcon;
private GUIContent _homeIcon;
private GUIContent _infoIcon;
private GUIContent _instrumentIcon;
private GUIContent _questionIcon;
private GUIStyle _orangeUpdateLabelStyle;
private GUIStyle _orangeUpdateIconStyle;
//private static readonly Texture2D _triggerAdNotEnabledTexture = new Texture2D(1, 1);
private static bool _checkedProjectNames = false;
private const string _unityToken = "KKy7MQNc2TEUOeK0EMtR";
private const string _gaUrl = "https://userapi.gameanalytics.com/ext/v1/";
private const int MaxNumberOfDimensions = 20;
private int selectedPlatformIndex = 0;
private string[] availablePlatforms;
void OnEnable()
{
GameAnalyticsSDK.Setup.Settings ga = target as GameAnalyticsSDK.Setup.Settings;
if (ga.UpdateIcon == null)
{
ga.UpdateIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/update_orange.png", typeof(Texture2D));
}
if (ga.DeleteIcon == null)
{
ga.DeleteIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/delete.png", typeof(Texture2D));
}
if (ga.GameIcon == null)
{
ga.GameIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/game.png", typeof(Texture2D));
}
if (ga.HomeIcon == null)
{
ga.HomeIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/home.png", typeof(Texture2D));
}
if (ga.InfoIcon == null)
{
ga.InfoIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/info.png", typeof(Texture2D));
}
if (ga.InstrumentIcon == null)
{
ga.InstrumentIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/instrument.png", typeof(Texture2D));
}
if (ga.QuestionIcon == null)
{
ga.QuestionIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/question.png", typeof(Texture2D));
}
if (ga.UserIcon == null)
{
ga.UserIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/user.png", typeof(Texture2D));
}
if (_gameSetupIcon == null)
{
_gameSetupIcon = new GUIContent(ga.InfoIcon, "Game Setup.");
}
if (_customDimensionsIcon == null)
{
_customDimensionsIcon = new GUIContent(ga.InfoIcon, "Custom Dimensions.");
}
if (_resourceTypesIcon == null)
{
_resourceTypesIcon = new GUIContent(ga.InfoIcon, "Resource Types.");
}
if (_advancedSettingsIcon == null)
{
_advancedSettingsIcon = new GUIContent(ga.InfoIcon, "Advanced Settings.");
}
if (_debugSettingsIcon == null)
{
_debugSettingsIcon = new GUIContent(ga.InfoIcon, "Debug Settings.");
}
if (_deleteIcon == null)
{
_deleteIcon = new GUIContent(ga.DeleteIcon, "Delete.");
}
if (_homeIcon == null)
{
_homeIcon = new GUIContent(ga.HomeIcon, "Your GameAnalytics webpage tool.");
}
if (_instrumentIcon == null)
{
_instrumentIcon = new GUIContent(ga.InstrumentIcon, "GameAnalytics setup guide.");
}
if (_questionIcon == null)
{
_questionIcon = new GUIContent(ga.QuestionIcon, "GameAnalytics support.");
}
if (ga.Logo == null)
{
ga.Logo = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/gaLogo.png", typeof(Texture2D));
}
}
public override void OnInspectorGUI()
{
GameAnalyticsSDK.Setup.Settings ga = target as GameAnalyticsSDK.Setup.Settings;
EditorGUI.indentLevel = 1;
EditorGUILayout.Space();
if (ga.SignupButton == null)
{
GUIStyle signupButton = new GUIStyle(GUI.skin.button);
signupButton.normal.background = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/default.png", typeof(Texture2D));
signupButton.active.background = (Texture2D)AssetDatabase.LoadAssetAtPath(AssetsPrependPath + "/Gizmos/GameAnalytics/Images/active.png", typeof(Texture2D));
signupButton.normal.textColor = Color.white;
signupButton.active.textColor = Color.white;
signupButton.fontSize = 14;
signupButton.fontStyle = FontStyle.Bold;
ga.SignupButton = signupButton;
}
#region Header section
GUILayout.BeginHorizontal();
GUILayout.Label(ga.Logo, new GUILayoutOption[] {
GUILayout.Width(32),
GUILayout.Height(32)
});
GUILayout.BeginVertical();
GUILayout.Space(8);
GUILayout.BeginHorizontal();
GUILayout.Label("Unity SDK v." + GameAnalyticsSDK.Setup.Settings.VERSION);
GUILayout.EndHorizontal();
GUILayout.EndVertical();
DrawLinkButton(_homeIcon, GUI.skin.label, "https://go.gameanalytics.com/login", GUILayout.Width(24), GUILayout.Height(24));
DrawLinkButton(_questionIcon, GUI.skin.label, "http://support.gameanalytics.com/", GUILayout.Width(24), GUILayout.Height(24));
DrawButton(_instrumentIcon, GUI.skin.label, OpenSignUpSwitchToGuideStep, GUILayout.Width(24), GUILayout.Height(24));
GUILayout.EndHorizontal();
EditorGUILayout.Space();
string updateStatus = GA_UpdateWindow.UpdateStatus(GameAnalyticsSDK.Setup.Settings.VERSION);
if (!updateStatus.Equals(string.Empty))
{
GUILayout.BeginHorizontal();
GUILayout.Space(10);
_orangeUpdateLabelStyle = new GUIStyle(EditorStyles.label);
_orangeUpdateLabelStyle.normal.textColor = new Color(0.875f, 0.309f, 0.094f);
_orangeUpdateIconStyle = new GUIStyle(EditorStyles.label);
if (GUILayout.Button(ga.UpdateIcon, _orangeUpdateIconStyle, GUILayout.MaxWidth(17)))
{
OpenUpdateWindow();
}
GUILayout.Label(updateStatus, _orangeUpdateLabelStyle);
if (ga.Organizations == null)
{
GUILayout.EndHorizontal();
GUILayout.Space(2);
}
}
else
{
if (ga.Organizations != null)
{
GUILayout.BeginHorizontal();
}
else
{
GUILayout.Space(22);
}
}
if (ga.Organizations != null)
{
GUILayout.FlexibleSpace();
float minW = 0;
float maxW = 0;
GUIContent email = new GUIContent(ga.EmailGA);
EditorStyles.miniLabel.CalcMinMaxWidth(email, out minW, out maxW);
GUILayout.Label(email, EditorStyles.miniLabel, GUILayout.MaxWidth(maxW));
GUILayout.BeginVertical();
//GUILayout.Space(-1);
if (GUILayout.Button("Log out", GUILayout.MaxWidth(67)))
{
ga.Organizations = null;
SetLoginStatus("Not logged in.", ga);
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
#endregion // Header section
#region IntroScreen
if (ga.IntroScreen)
{
bool finishIntro = false;
for (int i = 0; i < GameAnalytics.SettingsGA.Platforms.Count; ++i)
{
if (GameAnalytics.SettingsGA.GetGameKey(i).Length > 0 || GameAnalytics.SettingsGA.GetSecretKey(i).Length > 0)
{
finishIntro = true;
break;
}
}
if (finishIntro)
{
GameAnalytics.SettingsGA.IntroScreen = false;
}
else
{
if (!_checkedProjectNames && !EditorPrefs.GetBool("GA_Installed" + "-" + Application.dataPath, false))
{
_checkedProjectNames = true;
if (!PlayerSettings.companyName.Equals("DefaultCompany"))
{
GameAnalytics.SettingsGA.StudioName = PlayerSettings.companyName;
}
if (!PlayerSettings.productName.StartsWith("New Unity Project"))
{
GameAnalytics.SettingsGA.GameName = PlayerSettings.productName;
}
EditorPrefs.SetBool("GA_Installed" + "-" + Application.dataPath, true);
Selection.activeObject = GameAnalytics.SettingsGA;
}
GUILayout.Space(5);
Splitter(new Color(0.35f, 0.35f, 0.35f));
GUILayout.Space(10);
GUIStyle largeWhiteStyle = new GUIStyle(EditorStyles.whiteLargeLabel);
if (!Application.HasProLicense())
{
largeWhiteStyle = new GUIStyle(EditorStyles.largeLabel);
}
largeWhiteStyle.fontSize = 16;
//largeWhiteStyle.fontStyle = FontStyle.Bold;
DrawLabelWithFlexibleSpace("Thank you for downloading!", largeWhiteStyle, 30);
GUILayout.Space(20);
GUIStyle greyStyle = new GUIStyle(EditorStyles.label);
greyStyle.fontSize = 12;
DrawLabelWithFlexibleSpace("Get started tracking your game by signing up to", greyStyle, 20);
GUILayout.Space(-5);
DrawLabelWithFlexibleSpace("GameAnalytics for FREE.", greyStyle, 20);
GUILayout.Space(20);
DrawButtonWithFlexibleSpace("Sign up", ga.SignupButton, OpenSignUp, GUILayout.Width(175), GUILayout.Height(40));
GUILayout.Space(15);
Splitter(new Color(0.35f, 0.35f, 0.35f));
GUILayout.Space(15);
DrawLabelWithFlexibleSpace("Already have an account? Please login", greyStyle, 20);
GUILayout.Space(15);
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(3));
GUILayout.Label(_emailLabel, GUILayout.Width(75));
ga.EmailGA = EditorGUILayout.TextField("", ga.EmailGA);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(3));
GUILayout.Label(_passwordLabel, GUILayout.Width(75));
ga.PasswordGA = EditorGUILayout.PasswordField("", ga.PasswordGA);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(90));
if (GUILayout.Button("Login", new GUILayoutOption[] {
GUILayout.Width(130),
GUILayout.MaxHeight(30)
}))
{
ga.IntroScreen = false;
ga.SignUpOpen = false;
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Account;
ga.Organizations = null;
SetLoginStatus("Contacting Server..", ga);
LoginUser(ga);
}
GUILayout.Label("", GUILayout.Width(10));
GUILayout.BeginVertical();
GUILayout.Space(8);
DrawLinkButton("Forgot password?", EditorStyles.label, "https://go.gameanalytics.com/login?showreset&email=" + ga.EmailGA, GUILayout.Width(105));
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.Space(15);
Splitter(new Color(0.35f, 0.35f, 0.35f));
GUILayout.Space(15);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("I want to fill in my game keys manually", EditorStyles.label, GUILayout.Width(207)))
{
ga.IntroScreen = false;
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic;
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
}
#endregion // IntroScreen
else
{
//Tabs
GUILayout.BeginHorizontal();
GUIStyle activeTabStyle = new GUIStyle(EditorStyles.miniButtonMid);
GUIStyle activeTabStyleLeft = new GUIStyle(EditorStyles.miniButtonLeft);
GUIStyle activeTabStyleRight = new GUIStyle(EditorStyles.miniButtonRight);
activeTabStyle.normal = EditorStyles.miniButtonMid.active;
activeTabStyleLeft.normal = EditorStyles.miniButtonLeft.active;
activeTabStyleRight.normal = EditorStyles.miniButtonRight.active;
GUIStyle inactiveTabStyle = new GUIStyle(EditorStyles.miniButtonMid);
GUIStyle inactiveTabStyleLeft = new GUIStyle(EditorStyles.miniButtonLeft);
GUIStyle inactiveTabStyleRight = new GUIStyle(EditorStyles.miniButtonRight);
GUIStyle basicTabStyle = ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic ? activeTabStyleLeft : inactiveTabStyleLeft;
if (ga.Organizations == null)
{
if (GUILayout.Button(_account, ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Account ? activeTabStyleLeft : inactiveTabStyleLeft))
{
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Account;
}
basicTabStyle = ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic ? activeTabStyle : inactiveTabStyle;
}
if (GUILayout.Button(_setup, basicTabStyle))
{
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic;
}
if (GUILayout.Button(_advanced, ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Pref ? activeTabStyleRight : inactiveTabStyleRight))
{
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Pref;
}
GUILayout.EndHorizontal();
#region Settings.InspectorStates.Account
if (ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Account)
{
EditorGUILayout.Space();
GUILayout.Label("Already have an account with GameAnalytics?", EditorStyles.largeLabel);
EditorGUILayout.Space();
if (!string.IsNullOrEmpty(ga.LoginStatus) && !ga.LoginStatus.Equals("Not logged in."))
{
EditorGUILayout.Space();
if (ga.JustSignedUp && !ga.HideSignupWarning)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
EditorGUILayout.HelpBox("Please be aware that our service might take a few minutes to get ready to receive events. Click here to open Integration Status to follow the progress as you start sending events.", MessageType.Warning);
Rect r = GUILayoutUtility.GetLastRect();
if (GUI.Button(r, "", EditorStyles.label))
{
//Application.OpenURL("https://go.gameanalytics.com/login?token=" + ga.TokenGA + "&exp=" + ga.ExpireTime + "&goto=/game/" + ga.Studios[ga.SelectedStudio - 1].Games[ga.SelectedGame - 1].ID + "/initialize");
}
EditorGUIUtility.AddCursorRect(r, MouseCursor.Link);
if (GUILayout.Button("X"))
{
ga.HideSignupWarning = true;
}
GUILayout.EndHorizontal();
EditorGUILayout.Space();
}
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label("Status", GUILayout.Width(88));
GUILayout.Label(ga.LoginStatus);
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
if (ga.Organizations == null)
{
GUILayout.Label(_emailLabel, GUILayout.Width(75));
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-17));
ga.EmailGA = EditorGUILayout.TextField("", ga.EmailGA, GUILayout.MaxWidth(270));
GUILayout.EndHorizontal();
GUILayout.Space(12);
GUILayout.Label(_passwordLabel, GUILayout.Width(75));
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-17));
ga.PasswordGA = EditorGUILayout.PasswordField("", ga.PasswordGA, GUILayout.MaxWidth(270));
GUILayout.EndHorizontal();
GUILayout.Space(12);
GUILayout.BeginHorizontal();
GUILayout.Space(2);
if (GUILayout.Button("Login", new GUILayoutOption[] {
GUILayout.Width(130),
GUILayout.MaxHeight(40)
}))
{
ga.Organizations = null;
SetLoginStatus("Contacting Server..", ga);
LoginUser(ga);
}
GUILayout.Label("", GUILayout.Width(10));
GUILayout.BeginVertical();
GUILayout.Space(14);
if (GUILayout.Button("Forgot password?", EditorStyles.label, GUILayout.Width(105)))
{
Application.OpenURL("https://go.gameanalytics.com/login?showreset&email=" + ga.EmailGA);
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.Space(20);
Splitter(new Color(0.35f, 0.35f, 0.35f));
GUILayout.Space(16);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Sign up", new GUILayoutOption[] {
GUILayout.Width(130),
GUILayout.Height(40)
}))
{
GA_SignUp signup = ScriptableObject.CreateInstance<GA_SignUp>();
signup.maxSize = new Vector2(640, 600);
signup.minSize = new Vector2(640, 600);
signup.titleContent = new GUIContent("GameAnalytics - Sign up for FREE");
signup.ShowUtility();
signup.Opened();
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.Space(16);
Splitter(new Color(0.35f, 0.35f, 0.35f));
GUILayout.Space(16);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("I want to fill in my game keys manually", EditorStyles.label, GUILayout.Width(207)))
{
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic;
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
}
#endregion // Settings.InspectorStates.Account
#region Settings.InspectorStates.Basic
else if (ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic)
{
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUILayout.Space(-4);
GUILayout.Label("Game Setup", EditorStyles.largeLabel);
GUILayout.EndVertical();
#region Setup help
if (!_gameSetupIconOpen)
{
GUI.color = new Color(0.54f, 0.54f, 0.54f);
}
if (GUILayout.Button(_gameSetupIcon, GUIStyle.none, new GUILayoutOption[] {
GUILayout.Width(12),
GUILayout.Height(12)
}))
{
_gameSetupIconOpen = !_gameSetupIconOpen;
}
GUI.color = Color.white;
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (_gameSetupIconOpen)
{
GUILayout.BeginHorizontal();
TextAnchor tmpAnchor = GUI.skin.box.alignment;
GUI.skin.box.alignment = TextAnchor.UpperLeft;
Color tmpColor = GUI.skin.box.normal.textColor;
GUI.skin.box.normal.textColor = new Color(0.7f, 0.7f, 0.7f);
RectOffset tmpOffset = GUI.skin.box.padding;
GUI.skin.box.padding = new RectOffset(6, 6, 5, 32);
GUILayout.Box(_gameSetupIconMsg);
GUI.skin.box.alignment = tmpAnchor;
GUI.skin.box.normal.textColor = tmpColor;
GUI.skin.box.padding = tmpOffset;
//GUILayout.Label("Advanced settings are pretty awesome! They allow you to do all kinds of things, such as tracking Unity errors and exceptions, and frames per second (for performance). See http://www.support.gameanalytics.com", EditorStyles.wordWrappedMiniLabel);
GUILayout.EndHorizontal();
Rect tmpRect = GUILayoutUtility.GetLastRect();
if (GUI.Button(new Rect(tmpRect.x + 5, tmpRect.y + tmpRect.height - 25, 80, 20), "Learn more"))
{
Application.OpenURL("https://github.com/GameAnalytics/GA-SDK-UNITY/wiki/Settings#setup");
}
}
#endregion // Setup help
EditorGUILayout.Space();
if (!string.IsNullOrEmpty(ga.LoginStatus) && !ga.LoginStatus.Equals("Not logged in."))
{
if (ga.JustSignedUp && !ga.HideSignupWarning)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
EditorGUILayout.HelpBox("Please be aware that our service might take a few minutes to get ready to receive events. Click here to open Integration Status to follow the progress as you start sending events.", MessageType.Warning);
Rect r = GUILayoutUtility.GetLastRect();
if (GUI.Button(r, "", EditorStyles.label))
{
//Application.OpenURL("https://go.gameanalytics.com/login?token=" + ga.TokenGA + "&exp=" + ga.ExpireTime + "&goto=/game/" + ga.Studios[ga.SelectedStudio - 1].Games[ga.SelectedGame - 1].ID + "/initialize");
}
EditorGUIUtility.AddCursorRect(r, MouseCursor.Link);
if (GUILayout.Button("X"))
{
ga.HideSignupWarning = true;
}
GUILayout.EndHorizontal();
EditorGUILayout.Space();
}
if (GUILayout.Button("Add game"))
{
GA_SignUp signup = ScriptableObject.CreateInstance<GA_SignUp>();
signup.maxSize = new Vector2(640, 600);
signup.minSize = new Vector2(640, 600);
signup.TourStep = 1;
signup.titleContent = new GUIContent("GameAnalytics - Sign up for FREE");
signup.ShowUtility();
signup.Opened();
}
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label("Status", GUILayout.Width(63));
GUILayout.Label(ga.LoginStatus);
GUILayout.EndHorizontal();
}
Splitter(new Color(0.35f, 0.35f, 0.35f));
// sanity check
if(ga.SelectedPlatformOrganization.Count != GameAnalytics.SettingsGA.Platforms.Count)
{
int diff = ga.SelectedPlatformOrganization.Count - GameAnalytics.SettingsGA.Platforms.Count;
if(diff < 0)
{
int absDiff = Mathf.Abs(diff);
for(int i = 0; i < absDiff; ++i)
{
ga.SelectedPlatformOrganization.Add("");
}
}
else
{
for (int i = 0; i < diff; ++i)
{
ga.SelectedPlatformOrganization.RemoveAt(ga.SelectedPlatformOrganization.Count - 1);
}
}
}
for (int i = 0; i < GameAnalytics.SettingsGA.Platforms.Count; ++i)
{
ga.PlatformFoldOut[i] = EditorGUILayout.Foldout(ga.PlatformFoldOut[i], PlatformToString(GameAnalytics.SettingsGA.Platforms[i]));
if (ga.PlatformFoldOut[i])
{
if (ga.Organizations != null && ga.Organizations.Count > 0 && i < ga.SelectedOrganization.Count)
{
EditorGUILayout.Space();
//Splitter(new Color(0.35f, 0.35f, 0.35f));
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label(_organizationsLabel, GUILayout.Width(50));
string[] organizationNames = Organization.GetOrganizationNames(ga.Organizations);
if (ga.SelectedOrganization[i] >= organizationNames.Length)
{
ga.SelectedOrganization[i] = 0;
}
int tmpSelectedOrganization = ga.SelectedOrganization[i];
ga.SelectedOrganization[i] = EditorGUILayout.Popup("", ga.SelectedOrganization[i], organizationNames);
if (tmpSelectedOrganization != ga.SelectedOrganization[i])
{
ga.SelectedStudio[i] = 0;
ga.SelectedGame[i] = 0;
}
GUILayout.EndHorizontal();
if (ga.SelectedOrganization[i] > 0)
{
if (tmpSelectedOrganization != ga.SelectedOrganization[i])
{
SelectOrganization(ga.SelectedOrganization[i], ga, i);
}
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label(_studiosLabel, GUILayout.Width(50));
string[] studioNames = Studio.GetStudioNames(ga.Organizations[ga.SelectedOrganization[i] - 1].Studios);
if (ga.SelectedStudio[i] >= studioNames.Length)
{
ga.SelectedStudio[i] = 0;
}
int tmpSelectedStudio = ga.SelectedStudio[i];
ga.SelectedStudio[i] = EditorGUILayout.Popup("", ga.SelectedStudio[i], studioNames);
GUILayout.EndHorizontal();
if (ga.SelectedStudio[i] > 0)
{
if (tmpSelectedStudio != ga.SelectedStudio[i])
{
SelectStudio(ga.SelectedStudio[i], ga, i);
}
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label(_gamesLabel, GUILayout.Width(50));
string[] gameNames = Studio.GetGameNames(ga.SelectedStudio[i] - 1, ga.Organizations[ga.SelectedOrganization[i] - 1].Studios);
if (ga.SelectedGame[i] >= gameNames.Length)
{
ga.SelectedGame[i] = 0;
}
int tmpSelectedGame = ga.SelectedGame[i];
ga.SelectedGame[i] = EditorGUILayout.Popup("", ga.SelectedGame[i], gameNames);
GUILayout.EndHorizontal();
if (ga.SelectedStudio[i] > 0 && tmpSelectedGame != ga.SelectedGame[i])
{
SelectGame(ga.SelectedGame[i], ga, i);
}
}
else if (tmpSelectedStudio != ga.SelectedStudio[i])
{
SetLoginStatus("Please select studio..", ga);
}
}
else if (tmpSelectedOrganization != ga.SelectedOrganization[i])
{
SetLoginStatus("Please select organization..", ga);
}
}
else
{
GUILayout.BeginHorizontal();
GUILayout.Label(_organizationsLabel, GUILayout.Width(85));
GUILayout.Space(-10);
GUILayout.Label(!string.IsNullOrEmpty(ga.SelectedPlatformOrganization[i]) ? ga.SelectedPlatformOrganization[i] : "N/A");
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label(_studiosLabel, GUILayout.Width(85));
GUILayout.Space(-10);
GUILayout.Label(!string.IsNullOrEmpty(ga.SelectedPlatformStudio[i]) ? ga.SelectedPlatformStudio[i] : "N/A");
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label(_gamesLabel, GUILayout.Width(85));
GUILayout.Space(-10);
GUILayout.Label(!string.IsNullOrEmpty(ga.SelectedPlatformGame[i]) ? ga.SelectedPlatformGame[i] : "N/A");
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
GUILayout.Label(_publicKeyLabel, GUILayout.Width(70));
GUILayout.Space(-10);
string beforeGameKey = ga.GetGameKey(i);
string tmpGameKey = EditorGUILayout.TextField("", ga.GetGameKey(i));
if (!tmpGameKey.Equals(beforeGameKey))
{
ga.SelectedPlatformOrganization[i] = "";
ga.SelectedPlatformStudio[i] = "";
ga.SelectedPlatformGame[i] = "";
}
ga.UpdateGameKey(i, tmpGameKey);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label(_privateKeyLabel, GUILayout.Width(70));
GUILayout.Space(-10);
string beforeSecretKey = ga.GetSecretKey(i);
string tmpSecretKey = EditorGUILayout.TextField("", ga.GetSecretKey(i));
if (!tmpSecretKey.Equals(beforeSecretKey))
{
ga.SelectedPlatformOrganization[i] = "";
ga.SelectedPlatformStudio[i] = "";
ga.SelectedPlatformGame[i] = "";
}
ga.UpdateSecretKey(i, tmpSecretKey);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
switch (GameAnalytics.SettingsGA.UsePlayerSettingsBuildNumber)
{
case true:
if (GameAnalytics.SettingsGA.Platforms[i] != RuntimePlatform.Android && GameAnalytics.SettingsGA.Platforms[i] != RuntimePlatform.IPhonePlayer)
{
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label(_build, GUILayout.Width(60));
ga.Build[i] = EditorGUILayout.TextField("", ga.Build[i]);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
}
else
{
if (GameAnalytics.SettingsGA.Platforms[i] == RuntimePlatform.Android)
{
ga.Build[i] = PlayerSettings.bundleVersion;
EditorGUILayout.HelpBox("Using Android Player Settings Version* number as build number in events. \nBuild number is currently set to \"" + ga.Build[i] + "\".", MessageType.Info);
}
if (GameAnalytics.SettingsGA.Platforms[i] == RuntimePlatform.IPhonePlayer)
{
#if UNITY_5_6_OR_NEWER
ga.Build[i] = PlayerSettings.bundleVersion;
EditorGUILayout.HelpBox("Using iOS Player Settings Version* number as build number in events. \nBuild number is currently set to \"" + ga.Build[i] + "\".", MessageType.Info);
#else
ga.Build[i] = PlayerSettings.iOS.buildNumber;
EditorGUILayout.HelpBox("Using iOS Player Settings Build number as build number in events. \nBuild number is currently set to \"" + ga.Build[i] + "\".", MessageType.Info);
#endif
}
}
break;
case false:
GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(7));
GUILayout.Label(_build, GUILayout.Width(60));
ga.Build[i] = EditorGUILayout.TextField("", ga.Build[i]);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
break;
}
if (ga.SelectedPlatformGameID[i] >= 0)
{
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
//GUILayout.Label("View", GUILayout.Width(65));
if (GUILayout.Button("Integration Status"))
{
if (string.IsNullOrEmpty(ga.TokenGA))
{
Application.OpenURL("https://go.gameanalytics.com/game/" + ga.SelectedPlatformGameID[i] + "/initialize");
}
else
{
Application.OpenURL("https://go.gameanalytics.com/login?token=" + ga.TokenGA + "&exp=" + ga.ExpireTime + "&goto=/game/" + ga.SelectedPlatformGameID[i] + "/initialize");
}
}
if (GUILayout.Button("Game Settings"))
{
if (string.IsNullOrEmpty(ga.TokenGA))
{
Application.OpenURL("https://go.gameanalytics.com/game/" + ga.SelectedPlatformGameID[i] + "/settings");
}
else
{
Application.OpenURL("https://go.gameanalytics.com/login?token=" + ga.TokenGA + "&exp=" + ga.ExpireTime + "&goto=/game/" + ga.SelectedPlatformGameID[i] + "/settings");
}
}
GUILayout.EndHorizontal();
}
}
if (GUILayout.Button("Remove platform"))
{
GameAnalytics.SettingsGA.RemovePlatformAtIndex(i);
this.availablePlatforms = GameAnalytics.SettingsGA.GetAvailablePlatforms();
this.selectedPlatformIndex = 0;
}
Splitter(new Color(0.35f, 0.35f, 0.35f));
}
if (this.availablePlatforms == null)
{
this.availablePlatforms = GameAnalytics.SettingsGA.GetAvailablePlatforms();
}
this.selectedPlatformIndex = EditorGUILayout.Popup("Platform to add", this.selectedPlatformIndex, this.availablePlatforms);
if (GUILayout.Button("Add platform"))
{
if (this.availablePlatforms[this.selectedPlatformIndex].Equals("WSA"))
{
GameAnalytics.SettingsGA.AddPlatform(RuntimePlatform.WSAPlayerARM);
}
else
{
GameAnalytics.SettingsGA.AddPlatform((RuntimePlatform)System.Enum.Parse(typeof(RuntimePlatform), this.availablePlatforms[this.selectedPlatformIndex]));
}
this.availablePlatforms = GameAnalytics.SettingsGA.GetAvailablePlatforms();
this.selectedPlatformIndex = 0;
}
#if UNITY_IOS || UNITY_TVOS
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
EditorGUILayout.HelpBox("PLEASE NOTICE: Xcode needs to be configured to work with GameAnalytics. Click here to learn more about the build process for iOS.", MessageType.Info);
if(GUI.Button(GUILayoutUtility.GetLastRect(), "", GUIStyle.none))
{
Application.OpenURL("https://github.com/GameAnalytics/GA-SDK-UNITY/wiki/Configure%20XCode");
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
#elif UNITY_ANDROID || UNITY_STANDALONE || UNITY_WEBGL || UNITY_WSA || UNITY_WP_8_1 || UNITY_TIZEN || UNITY_SAMSUNGTV
// Do nothing
#else
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
EditorGUILayout.HelpBox("PLEASE NOTICE: Currently the GameAnalytics Unity SDK does not support your selected build Platform. Please refer to the GameAnalytics documentation for additional information.", MessageType.Warning);
if (GUI.Button(GUILayoutUtility.GetLastRect(), "", GUIStyle.none))
{
Application.OpenURL("http://www.gameanalytics.com/docs");
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
#endif
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUILayout.Space(-4);
GUILayout.Label("Custom Dimensions", EditorStyles.largeLabel);
GUILayout.EndVertical();
if (!_customDimensionsIconOpen)
{
GUI.color = new Color(0.54f, 0.54f, 0.54f);
}
if (GUILayout.Button(_customDimensionsIcon, GUIStyle.none, GUILayout.Width(12), GUILayout.Height(12)))
{
_customDimensionsIconOpen = !_customDimensionsIconOpen;
}
GUI.color = Color.white;
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (_customDimensionsIconOpen)
{
GUILayout.BeginHorizontal();
TextAnchor tmpAnchor = GUI.skin.box.alignment;
GUI.skin.box.alignment = TextAnchor.UpperLeft;
Color tmpColor = GUI.skin.box.normal.textColor;
GUI.skin.box.normal.textColor = new Color(0.7f, 0.7f, 0.7f);
RectOffset tmpOffset = GUI.skin.box.padding;
GUI.skin.box.padding = new RectOffset(6, 6, 5, 32);
GUILayout.Box(_customDimensionsIconMsg);
GUI.skin.box.alignment = tmpAnchor;
GUI.skin.box.normal.textColor = tmpColor;
GUI.skin.box.padding = tmpOffset;
//GUILayout.Label("Advanced settings are pretty awesome! They allow you to do all kinds of things, such as tracking Unity errors and exceptions, and frames per second (for performance). See http://www.support.gameanalytics.com", EditorStyles.wordWrappedMiniLabel);
GUILayout.EndHorizontal();
Rect tmpRect = GUILayoutUtility.GetLastRect();
if (GUI.Button(new Rect(tmpRect.x + 5, tmpRect.y + tmpRect.height - 25, 80, 20), "Learn more"))
{
Application.OpenURL("https://github.com/GameAnalytics/GA-SDK-UNITY/wiki/Settings#custom-dimensions");
}
}
EditorGUILayout.Space();
EditorGUILayout.Space();
// Custom dimensions 1
ga.CustomDimensions01FoldOut = EditorGUILayout.Foldout(ga.CustomDimensions01FoldOut, new GUIContent(" " + _customDimensions01.text + " (" + ga.CustomDimensions01.Count + " / " + MaxNumberOfDimensions + " values)", _customDimensions01.tooltip));
if (ga.CustomDimensions01FoldOut)
{
List<int> c1ToRemove = new List<int>();
for (int i = 0; i < ga.CustomDimensions01.Count; i++)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
GUILayout.Label("-", GUILayout.Width(10));
ga.CustomDimensions01[i] = ValidateCustomDimensionEditor(EditorGUILayout.TextField(ga.CustomDimensions01[i]));
if (GUILayout.Button(_deleteIcon, GUI.skin.label, new GUILayoutOption[] {
GUILayout.Width(16),
GUILayout.Height(16)
}))
{
c1ToRemove.Add(i);
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
GUILayout.Space(2);
}
foreach (int i in c1ToRemove)
{
ga.CustomDimensions01.RemoveAt(i);
}
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
if (GUILayout.Button("Add", GUILayout.Width(63)))
{
if (ga.CustomDimensions01.Count < MaxNumberOfDimensions)
{
ga.CustomDimensions01.Add("New (" + (ga.CustomDimensions01.Count + 1) + ")");
}
}
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
// Custom dimensions 2
ga.CustomDimensions02FoldOut = EditorGUILayout.Foldout(ga.CustomDimensions02FoldOut, new GUIContent(" " + _customDimensions02.text + " (" + ga.CustomDimensions02.Count + " / " + MaxNumberOfDimensions + " values)", _customDimensions02.tooltip));
if (ga.CustomDimensions02FoldOut)
{
List<int> c2ToRemove = new List<int>();
for (int i = 0; i < ga.CustomDimensions02.Count; i++)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
GUILayout.Label("-", GUILayout.Width(10));
ga.CustomDimensions02[i] = ValidateCustomDimensionEditor(EditorGUILayout.TextField(ga.CustomDimensions02[i]));
if (GUILayout.Button(_deleteIcon, GUI.skin.label, new GUILayoutOption[] {
GUILayout.Width(16),
GUILayout.Height(16)
}))
{
c2ToRemove.Add(i);
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
GUILayout.Space(2);
}
foreach (int i in c2ToRemove)
{
ga.CustomDimensions02.RemoveAt(i);
}
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
if (GUILayout.Button("Add", GUILayout.Width(63)))
{
if (ga.CustomDimensions02.Count < MaxNumberOfDimensions)
{
ga.CustomDimensions02.Add("New (" + (ga.CustomDimensions02.Count + 1) + ")");
}
}
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
// Custom dimensions 3
ga.CustomDimensions03FoldOut = EditorGUILayout.Foldout(ga.CustomDimensions03FoldOut, new GUIContent(" " + _customDimensions03.text + " (" + ga.CustomDimensions03.Count + " / " + MaxNumberOfDimensions + " values)", _customDimensions03.tooltip));
if (ga.CustomDimensions03FoldOut)
{
List<int> c3ToRemove = new List<int>();
for (int i = 0; i < ga.CustomDimensions03.Count; i++)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
GUILayout.Label("-", GUILayout.Width(10));
ga.CustomDimensions03[i] = ValidateCustomDimensionEditor(EditorGUILayout.TextField(ga.CustomDimensions03[i]));
if (GUILayout.Button(_deleteIcon, GUI.skin.label, new GUILayoutOption[] {
GUILayout.Width(16),
GUILayout.Height(16)
}))
{
c3ToRemove.Add(i);
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
GUILayout.Space(2);
}
foreach (int i in c3ToRemove)
{
ga.CustomDimensions03.RemoveAt(i);
}
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
if (GUILayout.Button("Add", GUILayout.Width(63)))
{
if (ga.CustomDimensions03.Count < MaxNumberOfDimensions)
{
ga.CustomDimensions03.Add("New (" + (ga.CustomDimensions03.Count + 1) + ")");
}
}
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUILayout.Space(-4);
GUILayout.Label("Resource Types", EditorStyles.largeLabel);
GUILayout.EndVertical();
if (!_resourceTypesIconOpen)
{
GUI.color = new Color(0.54f, 0.54f, 0.54f);
}
if (GUILayout.Button(_resourceTypesIcon, GUIStyle.none, new GUILayoutOption[] {
GUILayout.Width(12),
GUILayout.Height(12)
}))
{
_resourceTypesIconOpen = !_resourceTypesIconOpen;
}
GUI.color = Color.white;
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (_resourceTypesIconOpen)
{
GUILayout.BeginHorizontal();
TextAnchor tmpAnchor = GUI.skin.box.alignment;
GUI.skin.box.alignment = TextAnchor.UpperLeft;
Color tmpColor = GUI.skin.box.normal.textColor;
GUI.skin.box.normal.textColor = new Color(0.7f, 0.7f, 0.7f);
RectOffset tmpOffset = GUI.skin.box.padding;
GUI.skin.box.padding = new RectOffset(6, 6, 5, 32);
GUILayout.Box(_resourceTypesIconMsg);
GUI.skin.box.alignment = tmpAnchor;
GUI.skin.box.normal.textColor = tmpColor;
GUI.skin.box.padding = tmpOffset;
GUILayout.EndHorizontal();
Rect tmpRect = GUILayoutUtility.GetLastRect();
if (GUI.Button(new Rect(tmpRect.x + 5, tmpRect.y + tmpRect.height - 25, 80, 20), "Learn more"))
{
Application.OpenURL("https://github.com/GameAnalytics/GA-SDK-UNITY/wiki/Settings#resource-types");
}
}
EditorGUILayout.Space();
EditorGUILayout.Space();
// Resource types
ga.ResourceCurrenciesFoldOut = EditorGUILayout.Foldout(ga.ResourceCurrenciesFoldOut, new GUIContent(" " + _resourceCurrrencies.text + " (" + ga.ResourceCurrencies.Count + " / " + MaxNumberOfDimensions + " values)", _resourceCurrrencies.tooltip));
if (ga.ResourceCurrenciesFoldOut)
{
List<int> rcToRemove = new List<int>();
for (int i = 0; i < ga.ResourceCurrencies.Count; i++)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
GUILayout.Label("-", GUILayout.Width(10));
ga.ResourceCurrencies[i] = ValidateResourceCurrencyEditor(EditorGUILayout.TextField(ga.ResourceCurrencies[i]));
if (GUILayout.Button(_deleteIcon, GUI.skin.label, new GUILayoutOption[] {
GUILayout.Width(16),
GUILayout.Height(16)
}))
{
rcToRemove.Add(i);
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
GUILayout.Space(2);
}
foreach (int i in rcToRemove)
{
ga.ResourceCurrencies.RemoveAt(i);
}
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
if (GUILayout.Button("Add", GUILayout.Width(63)))
{
if (ga.ResourceCurrencies.Count < MaxNumberOfDimensions)
{
ga.ResourceCurrencies.Add("NewCurrency"); // + (ga.ResourceCurrencies.Count + 1));
}
}
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
ga.ResourceItemTypesFoldOut = EditorGUILayout.Foldout(ga.ResourceItemTypesFoldOut, new GUIContent(" " + _resourceItemTypes.text + " (" + ga.ResourceItemTypes.Count + " / " + MaxNumberOfDimensions + " values)", _resourceItemTypes.tooltip));
if (ga.ResourceItemTypesFoldOut)
{
List<int> ritToRemove = new List<int>();
for (int i = 0; i < ga.ResourceItemTypes.Count; i++)
{
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
GUILayout.Label("-", GUILayout.Width(10));
//string tmp = ga.ResourceTypes[i];
ga.ResourceItemTypes[i] = ValidateResourceItemTypeEditor(EditorGUILayout.TextField(ga.ResourceItemTypes[i]));
if (GUILayout.Button(_deleteIcon, GUI.skin.label, new GUILayoutOption[] {
GUILayout.Width(16),
GUILayout.Height(16)
}))
{
ritToRemove.Add(i);
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.EndHorizontal();
GUILayout.Space(2);
}
foreach (int i in ritToRemove)
{
ga.ResourceItemTypes.RemoveAt(i);
}
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(21));
if (GUILayout.Button("Add", GUILayout.Width(63)))
{
if (ga.ResourceItemTypes.Count < MaxNumberOfDimensions)
{
ga.ResourceItemTypes.Add("New (" + (ga.ResourceItemTypes.Count + 1) + ")");
}
}
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
}
#endregion // Settings.InspectorStates.Basic
#region Settings.InspectorStates.Pref
else if (ga.CurrentInspectorState == GameAnalyticsSDK.Setup.Settings.InspectorStates.Pref)
{
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUILayout.Space(-4);
GUILayout.Label("Advanced Settings", EditorStyles.largeLabel);
GUILayout.EndVertical();
if (!_advancedSettingsIconOpen)
{
GUI.color = new Color(0.54f, 0.54f, 0.54f);
}
if (GUILayout.Button(_advancedSettingsIcon, GUIStyle.none, new GUILayoutOption[] {
GUILayout.Width(12),
GUILayout.Height(12)
}))
{
_advancedSettingsIconOpen = !_advancedSettingsIconOpen;
}
GUI.color = Color.white;
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (_advancedSettingsIconOpen)
{
GUILayout.BeginHorizontal();
TextAnchor tmpAnchor = GUI.skin.box.alignment;
GUI.skin.box.alignment = TextAnchor.UpperLeft;
Color tmpColor = GUI.skin.box.normal.textColor;
GUI.skin.box.normal.textColor = new Color(0.7f, 0.7f, 0.7f);
RectOffset tmpOffset = GUI.skin.box.padding;
GUI.skin.box.padding = new RectOffset(6, 6, 5, 32);
GUILayout.Box(_advancedSettingsIconMsg);
GUI.skin.box.alignment = tmpAnchor;
GUI.skin.box.normal.textColor = tmpColor;
GUI.skin.box.padding = tmpOffset;
GUILayout.EndHorizontal();
Rect tmpRect = GUILayoutUtility.GetLastRect();
if (GUI.Button(new Rect(tmpRect.x + 5, tmpRect.y + tmpRect.height - 25, 80, 20), "Learn more"))
{
Application.OpenURL("https://github.com/GameAnalytics/GA-SDK-UNITY/wiki/Settings#advanced");
}
}
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.UseManualSessionHandling = EditorGUILayout.Toggle("", ga.UseManualSessionHandling, GUILayout.Width(35));
GUILayout.Label(_useManualSessionHandling);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.UsePlayerSettingsBuildNumber = EditorGUILayout.Toggle("", ga.UsePlayerSettingsBuildNumber, GUILayout.Width(35));
GUILayout.Label(_usePlayerSettingsBunldeVersionForBuild);
GUILayout.EndHorizontal();
if (ga.UsePlayerSettingsBuildNumber)
{
#if UNITY_5_6_OR_NEWER
EditorGUILayout.HelpBox("PLEASE NOTICE: The SDK will use the Version* number (Android, iOS) from Player Settings as the build number in events.", MessageType.Info);
#else
EditorGUILayout.HelpBox("PLEASE NOTICE: The SDK will use the Build number (iOS) and the Version* number (Android) from Player Settings as the build number in events.", MessageType.Info);
#endif
}
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.SubmitErrors = EditorGUILayout.Toggle("", ga.SubmitErrors, GUILayout.Width(35));
GUILayout.Label(_gaSubmitErrors);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.NativeErrorReporting = EditorGUILayout.Toggle("", ga.NativeErrorReporting, GUILayout.Width(35));
GUILayout.Label(_gaNativeErrorReporting);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.SubmitFpsAverage = EditorGUILayout.Toggle("", ga.SubmitFpsAverage, GUILayout.Width(35));
GUILayout.Label(_gaFpsAverage);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.SubmitFpsCritical = EditorGUILayout.Toggle("", ga.SubmitFpsCritical, GUILayout.Width(35));
GUILayout.Label(_gaFpsCritical, GUILayout.Width(135));
GUI.enabled = ga.SubmitFpsCritical;
GUILayout.Label(_gaFpsCriticalThreshold, GUILayout.Width(40));
GUILayout.Label("", GUILayout.Width(-26));
int tmpFpsCriticalThreshold = 0;
if (int.TryParse(EditorGUILayout.TextField(ga.FpsCriticalThreshold.ToString(), GUILayout.Width(45)), out tmpFpsCriticalThreshold))
{
ga.FpsCriticalThreshold = Mathf.Max(Mathf.Min(tmpFpsCriticalThreshold, 99), 5);
}
GUI.enabled = true;
GUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUILayout.Space(-4);
GUILayout.Label("Debug Settings", EditorStyles.largeLabel);
GUILayout.EndVertical();
if (!_debugSettingsIconOpen)
{
GUI.color = new Color(0.54f, 0.54f, 0.54f);
}
if (GUILayout.Button(_debugSettingsIcon, GUIStyle.none, new GUILayoutOption[] {
GUILayout.Width(12),
GUILayout.Height(12)
}))
{
_debugSettingsIconOpen = !_debugSettingsIconOpen;
}
GUI.color = Color.white;
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (_debugSettingsIconOpen)
{
GUILayout.BeginHorizontal();
TextAnchor tmpAnchor = GUI.skin.box.alignment;
GUI.skin.box.alignment = TextAnchor.UpperLeft;
Color tmpColor = GUI.skin.box.normal.textColor;
GUI.skin.box.normal.textColor = new Color(0.7f, 0.7f, 0.7f);
RectOffset tmpOffset = GUI.skin.box.padding;
GUI.skin.box.padding = new RectOffset(6, 6, 5, 32);
GUILayout.Box(_debugSettingsIconMsg);
GUI.skin.box.alignment = tmpAnchor;
GUI.skin.box.normal.textColor = tmpColor;
GUI.skin.box.padding = tmpOffset;
GUILayout.EndHorizontal();
Rect tmpRect = GUILayoutUtility.GetLastRect();
if (GUI.Button(new Rect(tmpRect.x + 5, tmpRect.y + tmpRect.height - 25, 80, 20), "Learn more"))
{
Application.OpenURL("https://github.com/GameAnalytics/GA-SDK-UNITY/wiki/Settings#debug-settings");
}
}
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.InfoLogEditor = EditorGUILayout.Toggle("", ga.InfoLogEditor, GUILayout.Width(35));
GUILayout.Label(_infoLogEditor);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.InfoLogBuild = EditorGUILayout.Toggle("", ga.InfoLogBuild, GUILayout.Width(35));
GUILayout.Label(_infoLogBuild);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.VerboseLogBuild = EditorGUILayout.Toggle("", ga.VerboseLogBuild, GUILayout.Width(35));
GUILayout.Label(_verboseLogBuild);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginVertical();
GUILayout.Space(-4);
GUILayout.Label("IMEI", EditorStyles.largeLabel);
GUILayout.EndVertical();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.Width(-18));
ga.UseIMEI = EditorGUILayout.Toggle("", ga.UseIMEI, GUILayout.Width(35));
GUILayout.Label(_useIMEI);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
}
#endregion // Settings.InspectorStates.Pref
}
if (GUI.changed)
{
EditorUtility.SetDirty(ga);
}
}
private MessageType ConvertMessageType(GameAnalyticsSDK.Setup.Settings.MessageTypes msgType)
{
switch (msgType)
{
case GameAnalyticsSDK.Setup.Settings.MessageTypes.Error:
return MessageType.Error;
case GameAnalyticsSDK.Setup.Settings.MessageTypes.Info:
return MessageType.Info;
case GameAnalyticsSDK.Setup.Settings.MessageTypes.Warning:
return MessageType.Warning;
default:
return MessageType.None;
}
}
public static void SignupUser(GameAnalyticsSDK.Setup.Settings ga, GA_SignUp signup)
{
Hashtable jsonTable = new Hashtable();
jsonTable["email"] = ga.EmailGA;
jsonTable["password"] = ga.PasswordGA;
jsonTable["password_confirm"] = signup.PasswordConfirm;
jsonTable["first_name"] = signup.FirstName;
jsonTable["last_name"] = signup.LastName;
jsonTable["studio_name"] = ga.StudioName;
jsonTable["org_name"] = ga.OrganizationName;
jsonTable["org_identifier"] = ga.OrganizationIdentifier;
jsonTable["email_opt_out"] = signup.EmailOptIn;
jsonTable["accept_terms"] = signup.AcceptedTerms;
byte[] data = System.Text.Encoding.UTF8.GetBytes(GA_MiniJSON.Serialize(jsonTable));
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = new UnityWebRequest(_gaUrl + "user", UnityWebRequest.kHttpVerbPOST);
UploadHandlerRaw uH = new UploadHandlerRaw(data)
{
contentType = "application/json"
};
www.uploadHandler = uH;
www.downloadHandler = new DownloadHandlerBuffer();
Dictionary<string, string> headers = GA_EditorUtilities.WWWHeaders();
foreach (KeyValuePair<string, string> entry in headers)
{
www.SetRequestHeader(entry.Key, entry.Value);
}
#else
WWW www = new WWW(_gaUrl + "user", data, GA_EditorUtilities.WWWHeaders());
#endif
GA_ContinuationManager.StartCoroutine(SignupUserFrontend(www, ga, signup), () => www.isDone);
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator SignupUserFrontend(UnityWebRequest www, GameAnalyticsSDK.Setup.Settings ga, GA_SignUp signup)
#else
private static IEnumerator<WWW> SignupUserFrontend(WWW www, Settings ga, GA_SignUp signup)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
IDictionary<string, object> returnParam = null;
string error = "";
#if UNITY_2017_1_OR_NEWER
string text = www.downloadHandler.text;
#else
string text = www.text;
#endif
if (!string.IsNullOrEmpty(text))
{
returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
if (returnParam.ContainsKey("errors"))
{
IList<object> errorList = returnParam["errors"] as IList<object>;
if (errorList != null && errorList.Count > 0)
{
IDictionary<string, object> errors = errorList[0] as IDictionary<string, object>;
if (errors.ContainsKey("msg"))
{
error = errors["msg"].ToString();
}
}
}
}
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
if (!String.IsNullOrEmpty(error))
{
Debug.LogError(error);
SetLoginStatus("Failed to sign up.", ga);
signup.SignUpFailed();
}
else if (returnParam != null)
{
IList<object> resultList = returnParam["results"] as IList<object>;
IDictionary<string, object> results = resultList[0] as IDictionary<string, object>;
ga.TokenGA = results["token"].ToString();
ga.ExpireTime = results["exp"].ToString();
ga.JustSignedUp = true;
//ga.SignUpOpen = false;
ga.Organizations = null;
SetLoginStatus("Signed up. Getting data.", ga);
GetUserData(ga);
signup.SignUpComplete();
}
}
#if UNITY_5_4_OR_NEWER
else if(www.responseCode == 301 || www.responseCode == 404 || www.responseCode == 410)
{
Debug.LogError("Failed to sign up. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version: " + www.error + " " + error);
SetLoginStatus("Failed to sign up. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version.", ga);
signup.SignUpFailed();
}
#endif
else
{
Debug.LogError("Failed to sign up: " + www.error + " " + error);
SetLoginStatus("Failed to sign up.", ga);
signup.SignUpFailed();
}
}
catch
{
Debug.LogError("Failed to sign up");
SetLoginStatus("Failed to sign up.", ga);
signup.SignUpFailed();
}
}
private static void LoginUser(GameAnalyticsSDK.Setup.Settings ga)
{
Hashtable jsonTable = new Hashtable();
jsonTable["email"] = ga.EmailGA;
jsonTable["password"] = ga.PasswordGA;
byte[] data = System.Text.Encoding.UTF8.GetBytes(GA_MiniJSON.Serialize(jsonTable));
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = new UnityWebRequest(_gaUrl + "token", UnityWebRequest.kHttpVerbPOST);
UploadHandlerRaw uH = new UploadHandlerRaw(data)
{
contentType = "application/json"
};
www.uploadHandler = uH;
www.downloadHandler = new DownloadHandlerBuffer();
Dictionary<string, string> headers = GA_EditorUtilities.WWWHeaders();
foreach (KeyValuePair<string, string> entry in headers)
{
www.SetRequestHeader(entry.Key, entry.Value);
}
#else
WWW www = new WWW(_gaUrl + "token", data, GA_EditorUtilities.WWWHeaders());
#endif
GA_ContinuationManager.StartCoroutine(LoginUserFrontend(www, ga), () => www.isDone);
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator LoginUserFrontend(UnityWebRequest www, GameAnalyticsSDK.Setup.Settings ga)
#else
private static IEnumerator<WWW> LoginUserFrontend(WWW www, Settings ga)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
string error = "";
IDictionary<string, object> returnParam = null;
#if UNITY_2017_1_OR_NEWER
string text = www.downloadHandler.text;
#else
string text = www.text;
#endif
if (!string.IsNullOrEmpty(text))
{
returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
if (returnParam.ContainsKey("errors"))
{
IList<object> errorList = returnParam["errors"] as IList<object>;
if (errorList != null && errorList.Count > 0)
{
IDictionary<string, object> errors = errorList[0] as IDictionary<string, object>;
if (errors.ContainsKey("msg"))
{
error = errors["msg"].ToString();
}
}
}
}
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
if (!String.IsNullOrEmpty(error))
{
Debug.LogError(error);
SetLoginStatus("Failed to login.", ga);
}
else if (returnParam != null)
{
IList<object> resultList = returnParam["results"] as IList<object>;
IDictionary<string, object> results = resultList[0] as IDictionary<string, object>;
ga.TokenGA = results["token"].ToString();
ga.ExpireTime = results["exp"].ToString();
SetLoginStatus("Logged in. Getting data.", ga);
GetUserData(ga);
}
}
#if UNITY_5_4_OR_NEWER
else if (www.responseCode == 301 || www.responseCode == 404 || www.responseCode == 410)
{
Debug.LogError("Failed to login. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version: " + www.error + " " + error);
SetLoginStatus("Failed to login. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version.", ga);
}
#endif
else
{
Debug.LogError("Failed to login: " + www.error + " " + error);
SetLoginStatus("Failed to login.", ga);
}
}
catch
{
Debug.LogError("Failed to login");
SetLoginStatus("Failed to login.", ga);
}
}
private static void GetUserData(GameAnalyticsSDK.Setup.Settings ga)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = UnityWebRequest.Get(_gaUrl + "user");
Dictionary<string, string> headers = GA_EditorUtilities.WWWHeadersWithAuthorization(ga.TokenGA);
foreach (KeyValuePair<string, string> entry in headers)
{
www.SetRequestHeader(entry.Key, entry.Value);
}
#else
WWW www = new WWW(_gaUrl + "user", null, GA_EditorUtilities.WWWHeadersWithAuthorization(ga.TokenGA));
#endif
GA_ContinuationManager.StartCoroutine(GetUserDataFrontend(www, ga), () => www.isDone);
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator GetUserDataFrontend(UnityWebRequest www, GameAnalyticsSDK.Setup.Settings ga)
#else
private static IEnumerator<WWW> GetUserDataFrontend(WWW www, Settings ga)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
IDictionary<string, object> returnParam = null;
string error = "";
#if UNITY_2017_1_OR_NEWER
string text = www.downloadHandler.text;
#else
string text = www.text;
#endif
if (!string.IsNullOrEmpty(text))
{
returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
if (returnParam.ContainsKey("errors"))
{
IList<object> errorList = returnParam["errors"] as IList<object>;
if (errorList != null && errorList.Count > 0)
{
IDictionary<string, object> errors = errorList[0] as IDictionary<string, object>;
if (errors.ContainsKey("msg"))
{
error = errors["msg"].ToString();
}
}
}
}
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
if (!String.IsNullOrEmpty(error))
{
Debug.LogError(error);
SetLoginStatus("Failed to get data.", ga);
}
else if (returnParam != null)
{
IList<object> resultList = returnParam["results"] as IList<object>;
IDictionary<string, object> results = resultList[0] as IDictionary<string, object>;
IDictionary<string, object> orgs = results["organizations"] as IDictionary<string, object>;
IList<object> studioList = results["studios"] as IList<object>;
Dictionary<string, GameAnalyticsSDK.Setup.Organization> organizationMap = new Dictionary<string, GameAnalyticsSDK.Setup.Organization>();
List<GameAnalyticsSDK.Setup.Organization> returnOrganizations = new List<GameAnalyticsSDK.Setup.Organization>();
foreach(KeyValuePair<string, object> pair in orgs)
{
IDictionary<string, object> organization = pair.Value as IDictionary<string, object>;
GameAnalyticsSDK.Setup.Organization o = new GameAnalyticsSDK.Setup.Organization(organization["name"].ToString(), organization["id"].ToString());
returnOrganizations.Add(o);
organizationMap.Add(o.ID, o);
}
for (int s = 0; s < studioList.Count; s++)
{
IDictionary<string, object> studio = studioList[s] as IDictionary<string, object>;
if ((!studio.ContainsKey("demo") || !((bool)studio["demo"])) && (!studio.ContainsKey("archived") || !((bool)studio["archived"])))
{
List<GameAnalyticsSDK.Setup.Game> returnGames = new List<GameAnalyticsSDK.Setup.Game>();
List<object> gamesList = (List<object>)studio["games"];
for (int g = 0; g < gamesList.Count; g++)
{
IDictionary<string, object> game = gamesList[g] as IDictionary<string, object>;
if ((!game.ContainsKey("archived") || !((bool)game["archived"])) && (!game.ContainsKey("disabled") || !((bool)game["disabled"])))
{
returnGames.Add(new GameAnalyticsSDK.Setup.Game(game["name"].ToString(), int.Parse(game["id"].ToString()), game["key"].ToString(), game["secret"].ToString()));
}
}
GameAnalyticsSDK.Setup.Studio st = new GameAnalyticsSDK.Setup.Studio(studio["name"].ToString(), studio["id"].ToString(), studio["org_id"].ToString(), returnGames);
organizationMap[st.OrganizationID].Studios.Add(st);
}
}
ga.Organizations = returnOrganizations;
if (ga.Organizations.Count == 1 && ga.Organizations[0].Studios.Count == 1)
{
bool autoSelectedPlatform = false;
for (int i = 0; i < GameAnalytics.SettingsGA.Platforms.Count; ++i)
{
RuntimePlatform platform = GameAnalytics.SettingsGA.Platforms[i];
if (platform == ga.LastCreatedGamePlatform)
{
SelectOrganization(1, ga, i);
autoSelectedPlatform = true;
}
}
ga.LastCreatedGamePlatform = (RuntimePlatform)(-1);
SetLoginStatus(autoSelectedPlatform ? "Received data. Autoselected platform.." : "Received data. Add a platform..", ga);
}
else
{
SetLoginStatus("Received data. Add a platform..", ga);
}
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Basic;
}
}
#if UNITY_5_4_OR_NEWER
else if (www.responseCode == 301 || www.responseCode == 404 || www.responseCode == 410)
{
Debug.LogError("Failed to get data. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version: " + www.error + " " + error);
SetLoginStatus("Failed to get data. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version.", ga);
}
#endif
else
{
Debug.LogError("Failed to get user data: " + www.error + " " + error);
SetLoginStatus("Failed to get data.", ga);
}
}
catch (Exception e)
{
Debug.LogError("Failed to get user data: " + e.ToString() + ", " + e.StackTrace);
SetLoginStatus("Failed to get data.", ga);
}
}
public static void CreateGame(GameAnalyticsSDK.Setup.Settings ga, GA_SignUp signup, int organizationIndex, int studioIndex, string gameTitle, string googlePlayPublicKey, RuntimePlatform platform, AppFiguresGame appFiguresGame)
{
Hashtable jsonTable = new Hashtable();
if (appFiguresGame != null)
{
jsonTable["title"] = gameTitle;
jsonTable["store_id"] = appFiguresGame.AppID;
jsonTable["store"] = appFiguresGame.Store;
jsonTable["googleplay_key"] = string.IsNullOrEmpty(googlePlayPublicKey) ? null : googlePlayPublicKey;
}
else
{
jsonTable["title"] = gameTitle;
jsonTable["store_id"] = null;
jsonTable["store"] = null;
jsonTable["googleplay_key"] = string.IsNullOrEmpty(googlePlayPublicKey) ? null : googlePlayPublicKey;
}
byte[] data = System.Text.Encoding.UTF8.GetBytes(GA_MiniJSON.Serialize(jsonTable));
string url = _gaUrl + "studios/" + ga.Organizations[organizationIndex].Studios[studioIndex].ID + "/games";
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = new UnityWebRequest(url, UnityWebRequest.kHttpVerbPOST);
UploadHandlerRaw uH = new UploadHandlerRaw(data)
{
contentType = "application/json"
};
www.uploadHandler = uH;
www.downloadHandler = new DownloadHandlerBuffer();
Dictionary<string, string> headers = GA_EditorUtilities.WWWHeadersWithAuthorization(ga.TokenGA);
foreach (KeyValuePair<string, string> entry in headers)
{
www.SetRequestHeader(entry.Key, entry.Value);
}
#else
WWW www = new WWW(url, data, GA_EditorUtilities.WWWHeadersWithAuthorization(ga.TokenGA));
#endif
GA_ContinuationManager.StartCoroutine(CreateGameFrontend(www, ga, signup, platform, appFiguresGame), () => www.isDone);
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator CreateGameFrontend(UnityWebRequest www, GameAnalyticsSDK.Setup.Settings ga, GA_SignUp signup, RuntimePlatform platform, AppFiguresGame appFiguresGame)
#else
private static IEnumerator<WWW> CreateGameFrontend(WWW www, Settings ga, GA_SignUp signup, RuntimePlatform platform, AppFiguresGame appFiguresGame)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
IDictionary<string, object> returnParam = null;
string error = "";
#if UNITY_2017_1_OR_NEWER
string text = www.downloadHandler.text;
#else
string text = www.text;
#endif
if (!string.IsNullOrEmpty(text))
{
returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
if (returnParam.ContainsKey("errors"))
{
IList<object> errorList = returnParam["errors"] as IList<object>;
if (errorList != null && errorList.Count > 0)
{
IDictionary<string, object> errors = errorList[0] as IDictionary<string, object>;
if (errors.ContainsKey("msg"))
{
error = errors["msg"].ToString();
}
}
}
}
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
if (!String.IsNullOrEmpty(error))
{
Debug.LogError(error);
SetLoginStatus("Failed to create game.", ga);
signup.CreateGameFailed();
}
else
{
ga.LastCreatedGamePlatform = platform;
GetUserData(ga);
signup.CreateGameComplete();
}
}
#if UNITY_5_4_OR_NEWER
else if (www.responseCode == 301 || www.responseCode == 404 || www.responseCode == 410)
{
Debug.LogError("Failed to create game. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version: " + www.error + " " + error);
SetLoginStatus("Failed to create game. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version.", ga);
}
#endif
else
{
Debug.LogError("Failed to create game: " + www.error + " " + error);
SetLoginStatus("Failed to create game.", ga);
signup.CreateGameFailed();
}
}
catch
{
Debug.LogError("Failed to create game");
SetLoginStatus("Failed to create game.", ga);
signup.CreateGameFailed();
}
}
public static void GetAppFigures(GameAnalyticsSDK.Setup.Settings ga, GA_SignUp signup)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = UnityWebRequest.Get(_gaUrl + "apps/search?query=" + UnityWebRequest.EscapeURL(ga.GameName));
Dictionary<string, string> headers = GA_EditorUtilities.WWWHeadersWithAuthorization(ga.TokenGA);
foreach (KeyValuePair<string, string> pair in headers)
{
www.SetRequestHeader(pair.Key, pair.Value);
}
GA_ContinuationManager.StartCoroutine(GetAppFiguresFrontend(www, ga, signup, ga.GameName), () => www.isDone);
#else
WWW www = new WWW(_gaUrl + "apps/search?query=" + WWW.EscapeURL(ga.GameName), null, GA_EditorUtilities.WWWHeadersWithAuthorization(ga.TokenGA));
GA_ContinuationManager.StartCoroutine(GetAppFiguresFrontend(www, ga, signup, ga.GameName), () => www.isDone);
#endif
if (ga.AmazonIcon == null)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest wwwAmazon = UnityWebRequestTexture.GetTexture("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/amazon.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwAmazon, "amazon_appstore", signup), () => wwwAmazon.isDone);
#else
WWW wwwAmazon = new WWW("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/amazon.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwAmazon, "amazon_appstore", signup), () => wwwAmazon.isDone);
#endif
}
if (ga.GooglePlayIcon == null)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest wwwGoogle = UnityWebRequestTexture.GetTexture("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/google_play.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwGoogle, "google_play", signup), () => wwwGoogle.isDone);
#else
WWW wwwGoogle = new WWW("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/google_play.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwGoogle, "google_play", signup), () => wwwGoogle.isDone);
#endif
}
if (ga.iosIcon == null)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest wwwIos = UnityWebRequestTexture.GetTexture("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/ios.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwIos, "apple:ios", signup), () => wwwIos.isDone);
#else
WWW wwwIos = new WWW("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/ios.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwIos, "apple:ios", signup), () => wwwIos.isDone);
#endif
}
if (ga.macIcon == null)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest wwwMac = UnityWebRequestTexture.GetTexture("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/mac.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwMac, "apple:mac", signup), () => wwwMac.isDone);
#else
WWW wwwMac = new WWW("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/mac.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwMac, "apple:mac", signup), () => wwwMac.isDone);
#endif
}
if (ga.windowsPhoneIcon == null)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest wwwWindowsPhone = UnityWebRequestTexture.GetTexture("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/windows_phone.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwWindowsPhone, "windows_phone", signup), () => wwwWindowsPhone.isDone);
#else
WWW wwwWindowsPhone = new WWW("http://public.gameanalytics.com/resources/images/sdk_doc/appstore_icons/windows_phone.png");
GA_ContinuationManager.StartCoroutine(signup.GetAppStoreIconTexture(wwwWindowsPhone, "windows_phone", signup), () => wwwWindowsPhone.isDone);
#endif
}
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator GetAppFiguresFrontend(UnityWebRequest www, GameAnalyticsSDK.Setup.Settings ga, GA_SignUp signup, string gameName)
#else
private static IEnumerator<WWW> GetAppFiguresFrontend(WWW www, Settings ga, GA_SignUp signup, string gameName)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
IDictionary<string, object> returnParam = null;
string error = "";
string text;
#if UNITY_2017_1_OR_NEWER
text = www.downloadHandler.text;
#else
text = www.text;
#endif
if (!string.IsNullOrEmpty(text))
{
returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
if (returnParam.ContainsKey("errors"))
{
IList<object> errorList = returnParam["errors"] as IList<object>;
if (errorList != null && errorList.Count > 0)
{
IDictionary<string, object> errors = errorList[0] as IDictionary<string, object>;
if (errors.ContainsKey("msg"))
{
error = errors["msg"].ToString();
}
}
}
}
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
if (!String.IsNullOrEmpty(error))
{
Debug.LogError(error);
SetLoginStatus("Failed to get app.", ga);
}
else if (returnParam != null)
{
IList<object> resultList = returnParam["results"] as IList<object>;
List<AppFiguresGame> appFiguresGames = new List<AppFiguresGame>();
for (int s = 0; s < resultList.Count; s++)
{
IDictionary<string, object> result = resultList[s] as IDictionary<string, object>;
string name = result["title"].ToString();
string appID = result["store_id"].ToString();
string store = result["store"].ToString();
string developer = result["developer"].ToString();
string iconUrl = result["image"].ToString();
if (store.Equals("apple") || store.Equals("google_play") || store.Equals("amazon_appstore"))
{
appFiguresGames.Add(new AppFiguresGame(name, appID, store, developer, iconUrl, signup));
}
}
signup.AppFigComplete(gameName, appFiguresGames);
}
}
else
{
// expired tokens / not signed in
#if UNITY_2017_1_OR_NEWER
if (www.responseCode == 401)
#else
if (www.responseHeaders["status"] != null && www.responseHeaders["status"].Contains("401"))
#endif
{
Selection.objects = new UnityEngine.Object[] { AssetDatabase.LoadAssetAtPath("Assets/Resources/GameAnalytics/Settings.asset", typeof(GameAnalyticsSDK.Setup.Settings)) };
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Account;
string message = "Please sign-in and try again to search for your game in the stores.";
SetLoginStatus(message, ga);
Debug.LogError(message);
}
#if UNITY_5_4_OR_NEWER
else if (www.responseCode == 301 || www.responseCode == 404 || www.responseCode == 410)
{
Debug.LogError("Failed to find app. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version: " + www.error + " " + error);
SetLoginStatus("Failed to find app. GameAnalytics request not successful. API was changed. Please update your SDK to the latest version.", ga);
}
#endif
else
{
Debug.LogError("Failed to find app: " + www.error + " " + text);
SetLoginStatus("Failed to find app.", ga);
}
}
}
catch (Exception e)
{
Debug.LogError("Failed to find app: " + e.ToString() + ", " + e.StackTrace);
SetLoginStatus("Failed to find app.", ga);
}
}
private static void SelectOrganization(int index, GameAnalyticsSDK.Setup.Settings ga, int platform)
{
ga.SelectedOrganization[platform] = index;
if (ga.Organizations[index - 1].Studios.Count == 1)
{
SelectStudio(1, ga, platform);
}
else
{
SetLoginStatus("Please select studio..", ga);
}
}
private static void SelectStudio(int index, GameAnalyticsSDK.Setup.Settings ga, int platform)
{
ga.SelectedStudio[platform] = index;
if (ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[index - 1].Games.Count == 1)
{
if (ga.IsGameKeyValid(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[0].GameKey) &&
ga.IsSecretKeyValid(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[0].SecretKey))
{
SelectGame(1, ga, platform);
}
}
else
{
SetLoginStatus("Please select game..", ga);
}
}
private static void SelectGame(int index, GameAnalyticsSDK.Setup.Settings ga, int platform)
{
ga.SelectedGame[platform] = index;
if (index == 0)
{
ga.UpdateGameKey(platform, "");
ga.UpdateSecretKey(platform, "");
}
else if (ga.IsGameKeyValid(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].GameKey) &&
ga.IsSecretKeyValid(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].SecretKey))
{
ga.SelectedPlatformOrganization[platform] = ga.Organizations[ga.SelectedOrganization[platform] - 1].Name;
ga.SelectedPlatformStudio[platform] = ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Name;
ga.SelectedPlatformGame[platform] = ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].Name;
ga.SelectedPlatformGameID[platform] = ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].ID;
ga.UpdateGameKey(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].GameKey);
ga.UpdateSecretKey(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].SecretKey);
SetLoginStatus("Received keys. Ready to go!", ga);
}
else
{
if (!ga.IsGameKeyValid(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].GameKey))
{
Debug.LogError("[GameAnalytics] Game key already exists for another platform. Platforms can't use the same key.");
ga.SelectedGame[platform] = 0;
}
else if (!ga.IsSecretKeyValid(platform, ga.Organizations[ga.SelectedOrganization[platform] - 1].Studios[ga.SelectedStudio[platform] - 1].Games[index - 1].SecretKey))
{
Debug.LogError("[GameAnalytics] Secret key already exists for another platform. Platforms can't use the same key.");
ga.SelectedGame[platform] = 0;
}
}
}
private static void SetLoginStatus(string status, GameAnalyticsSDK.Setup.Settings ga)
{
ga.LoginStatus = status;
EditorUtility.SetDirty(ga);
}
public static void CheckForUpdates()
{
if (GameAnalyticsSDK.Setup.Settings.CheckingForUpdates)
{
return;
}
GameAnalyticsSDK.Setup.Settings.CheckingForUpdates = true;
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = UnityWebRequest.Get("https://s3.amazonaws.com/public.gameanalytics.com/sdk_status/current.json");
#else
WWW www = new WWW("https://s3.amazonaws.com/public.gameanalytics.com/sdk_status/current.json");
#endif
GA_ContinuationManager.StartCoroutine(CheckForUpdatesCoroutine(www), () => www.isDone);
}
private static void GetChangeLogsAndShowUpdateWindow(string newVersion)
{
#if UNITY_2017_1_OR_NEWER
UnityWebRequest www = UnityWebRequest.Get("https://s3.amazonaws.com/public.gameanalytics.com/sdk_status/change_logs.json");
#else
WWW www = new WWW("https://s3.amazonaws.com/public.gameanalytics.com/sdk_status/change_logs.json");
#endif
GA_ContinuationManager.StartCoroutine(GetChangeLogsAndShowUpdateWindowCoroutine(www, newVersion), () => www.isDone);
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator CheckForUpdatesCoroutine(UnityWebRequest www)
#else
private static IEnumerator CheckForUpdatesCoroutine(WWW www)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
string text;
#if UNITY_2017_1_OR_NEWER
text = www.downloadHandler.text;
#else
text = www.text;
#endif
IDictionary<string, object> returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
if (returnParam.ContainsKey("unity"))
{
IDictionary<string, object> unityParam = returnParam["unity"] as IDictionary<string, object>;
if (unityParam.ContainsKey("version"))
{
string newVersion = (returnParam["unity"] as IDictionary<string, object>)["version"].ToString();
if (IsNewVersion(newVersion, GameAnalyticsSDK.Setup.Settings.VERSION))
{
GetChangeLogsAndShowUpdateWindow(newVersion);
}
}
}
}
}
catch
{
GameAnalyticsSDK.Setup.Settings.CheckingForUpdates = false;
}
}
#if UNITY_2017_1_OR_NEWER
private static IEnumerator GetChangeLogsAndShowUpdateWindowCoroutine(UnityWebRequest www, string newVersion)
#else
private static IEnumerator<WWW> GetChangeLogsAndShowUpdateWindowCoroutine(WWW www, string newVersion)
#endif
{
#if UNITY_2017_1_OR_NEWER
#if UNITY_2017_2_OR_NEWER
yield return www.SendWebRequest();
#else
yield return www.Send();
#endif
while (!www.isDone)
yield return null;
#else
yield return www;
#endif
try
{
#if UNITY_2020_1_OR_NEWER
if (!(www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError))
#elif UNITY_2017_1_OR_NEWER
if (!(www.isNetworkError || www.isHttpError))
#else
if (string.IsNullOrEmpty(www.error))
#endif
{
string text;
#if UNITY_2017_1_OR_NEWER
text = www.downloadHandler.text;
#else
text = www.text;
#endif
IDictionary<string, object> returnParam = GA_MiniJSON.Deserialize(text) as IDictionary<string, object>;
IList<object> unity = (returnParam["unity"] as IList<object>);
string newChanges = "";
for (int i = 0; i < unity.Count; i++)
{
IDictionary<string, object> unityHash = unity[i] as IDictionary<string, object>;
IList<object> changes = (unityHash["changes"] as IList<object>);
if (unityHash["version"].ToString() == GameAnalyticsSDK.Setup.Settings.VERSION)
{
break;
}
if (string.IsNullOrEmpty(newChanges))
{
newChanges = unityHash["version"].ToString();
}
else
{
newChanges += "\n\n" + unityHash["version"].ToString();
}
for (int u = 0; u < changes.Count; u++)
{
if (string.IsNullOrEmpty(newChanges))
{
newChanges = "- " + changes[u].ToString();
}
else
{
newChanges += "\n- " + changes[u].ToString();
}
}
if (unityHash["version"].ToString() == newVersion)
{
GA_UpdateWindow.SetNewVersion(newVersion);
}
}
string skippedVersion = EditorPrefs.GetString("ga_skip_version" + "-" + Application.dataPath, "");
GA_UpdateWindow.SetChanges(newChanges);
if (!skippedVersion.Equals(newVersion))
{
OpenUpdateWindow();
}
GameAnalyticsSDK.Setup.Settings.CheckingForUpdates = false;
}
}
catch
{
GameAnalyticsSDK.Setup.Settings.CheckingForUpdates = false;
}
}
private static void OpenUpdateWindow()
{
#if UNITY_2018_2_OR_NEWER
if(!Application.isBatchMode)
#else
string commandLineOptions = System.Environment.CommandLine;
if (!commandLineOptions.Contains("-batchmode"))
#endif
{
// TODO: possible to close existing window if already there?
//GA_UpdateWindow updateWindow = ScriptableObject.CreateInstance<GA_UpdateWindow> ();
GA_UpdateWindow updateWindow = (GA_UpdateWindow)EditorWindow.GetWindow(typeof(GA_UpdateWindow), utility: true);
updateWindow.position = new Rect(150, 150, 415, 340);
updateWindow.titleContent = new GUIContent("An update for GameAnalytics is available!");
updateWindow.Show();
}
}
public static void Splitter(Color rgb, float thickness = 1, int margin = 0)
{
GUIStyle splitter = new GUIStyle();
splitter.normal.background = EditorGUIUtility.whiteTexture;
splitter.stretchWidth = true;
splitter.margin = new RectOffset(margin, margin, 7, 7);
Rect position = GUILayoutUtility.GetRect(GUIContent.none, splitter, GUILayout.Height(thickness));
if(Event.current.type == EventType.Repaint)
{
Color restoreColor = GUI.color;
GUI.color = rgb;
splitter.Draw(position, false, false, false, false);
GUI.color = restoreColor;
}
}
private static string PlatformToString(RuntimePlatform platform)
{
string result = platform.ToString();
if (platform == RuntimePlatform.IPhonePlayer)
{
result = "iOS";
}
if (platform == RuntimePlatform.tvOS) {
result = "tvOS";
}
else if (platform == RuntimePlatform.WSAPlayerARM ||
platform == RuntimePlatform.WSAPlayerX64 ||
platform == RuntimePlatform.WSAPlayerX86)
{
result = "WSA";
}
return result;
}
// versionstring is:
// [majorVersion].[minorVersion].[patchnumber]
static bool IsNewVersion(string newVersion, string currentVersion)
{
int[] newVersionInts = GetVersionIntegersFromString(newVersion);
int[] currentVersionInts = GetVersionIntegersFromString(currentVersion);
if(newVersionInts == null || currentVersionInts == null)
{
return false;
}
// compare majorVersion
if(newVersionInts[0] > currentVersionInts[0])
{
return true;
}
else if(newVersionInts[0] < currentVersionInts[0])
{
return false;
}
// compare minorVersion (majorVersion is unchanged)
if(newVersionInts[1] > currentVersionInts[1])
{
return true;
}
else if(newVersionInts[1] < currentVersionInts[1])
{
return false;
}
// compare patchnumber (majorVersion, minorVersion is unchanged)
if(newVersionInts[2] > currentVersionInts[2])
{
return true;
}
// not valid new version
return false;
}
// version string need to be: x.y.z
// return validated ints in array or null
static int[] GetVersionIntegersFromString(string versionString)
{
string[] versionNumbers = versionString.Split('.');
if(versionNumbers.Length != 3)
{
return null;
}
// container for validated version integers
int[] validatedVersionNumbers = new int[3];
// verify int parsing
bool isIntMajorVersion = int.TryParse(versionNumbers[0], out validatedVersionNumbers[0]);
bool isIntMinorVersion = int.TryParse(versionNumbers[1], out validatedVersionNumbers[1]);
bool isIntPatchnumber = int.TryParse(versionNumbers[2], out validatedVersionNumbers[2]);
if(isIntMajorVersion && isIntMinorVersion && isIntPatchnumber)
{
return validatedVersionNumbers;
}
else
{
return null;
}
}
#region Button actions
private void OpenSignUp()
{
GameAnalyticsSDK.Setup.Settings ga = target as GameAnalyticsSDK.Setup.Settings;
ga.IntroScreen = false;
ga.CurrentInspectorState = GameAnalyticsSDK.Setup.Settings.InspectorStates.Account;
ga.SignUpOpen = true;
GA_SignUp signup = ScriptableObject.CreateInstance<GA_SignUp>();
signup.maxSize = new Vector2(640, 600);
signup.minSize = new Vector2(640, 600);
signup.titleContent = new GUIContent("GameAnalytics - Sign up for FREE");
signup.ShowUtility();
signup.Opened();
}
#endregion // Button actions
#region Helper functions
private static void OpenSignUpSwitchToGuideStep()
{
GA_SignUp signup = ScriptableObject.CreateInstance<GA_SignUp>();
signup.maxSize = new Vector2(640, 600);
signup.minSize = new Vector2(640, 600);
signup.titleContent = new GUIContent("GameAnalytics - Sign up for FREE");
signup.ShowUtility();
signup.Opened();
signup.SwitchToGuideStep();
}
private static void DrawLinkButton(string text, GUIStyle style, string url, params GUILayoutOption[] options)
{
DrawLinkButton(new GUIContent(text), style, url, options);
}
private static void DrawLinkButton(GUIContent content, GUIStyle style, string url, params GUILayoutOption[] options)
{
Action action = () => Application.OpenURL(url);
DrawButton(content, style, action, options);
}
private static void DrawButton(string text, GUIStyle style, Action action, params GUILayoutOption[] options)
{
DrawButton(new GUIContent(text), style, action, options);
}
private static void DrawButton(GUIContent content, GUIStyle style, Action action, params GUILayoutOption[] options)
{
if(GUILayout.Button(content, style, options))
{
action();
}
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
}
private static void DrawButtonWithFlexibleSpace(string text, GUIStyle style, Action action, params GUILayoutOption[] options)
{
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
DrawButton(text, style, action, options);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
private static void DrawLabelWithFlexibleSpace(string text, GUIStyle style, int height)
{
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(text, style, new GUILayoutOption[] { GUILayout.Height(height) });
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
#endregion // Helper functions
#region UIvalidation
/// <summary>
/// Check if a string matches a defined pattern
/// </summary>
/// <returns><c>true</c>, if match <c>false</c> otherwise.</returns>
/// <param name="s">Given string</param>
/// <param name="pattern">Pattern.</param>
public static bool StringMatch(string s, string pattern)
{
if(s == null || pattern == null)
{
return false;
}
return Regex.IsMatch(s, pattern);
}
private string ValidateResourceCurrencyEditor(string currency)
{
if (!StringMatch (currency, "^[A-Za-z]+$")) {
if (currency != null) {
Debug.LogError ("Validation fail - resource currency: Cannot contain other characters than 'A-Za-z'. String:'" + currency + "'");
}
return "Empty";
}
if (ConsistsOfWhiteSpace(currency)) {
return "Empty";
}
return currency;
}
private string ValidateResourceItemTypeEditor (string itemType)
{
if (itemType.Length > 64) {
Debug.LogError ("Validation fail - resource itemType cannot be longer than 64 chars.");
return "Empty";
}
if (!StringMatch (itemType, "^[A-Za-z0-9\\s\\-_\\.\\(\\)\\!\\?]{1,64}$")) {
if (itemType != null) {
Debug.LogError ("Validation fail - resource itemType: Cannot contain other characters than A-z, 0-9, -_., ()!?. String: '" + itemType + "'");
}
return "Empty";
}
if (ConsistsOfWhiteSpace(itemType)) {
return "Empty";
}
return itemType;
}
private string ValidateCustomDimensionEditor(string customDimension)
{
if (customDimension.Length > 32) {
Debug.LogError ("Validation fail - custom dimension cannot be longer than 32 chars.");
return "Empty";
}
if (!StringMatch (customDimension, "^[A-Za-z0-9\\s\\-_\\.\\(\\)\\!\\?]{1,32}$")) {
if (customDimension != null) {
Debug.LogError ("Validation fail - custom dimension: Cannot contain other characters than A-z, 0-9, -_., ()!?. String: '" + customDimension + "'");
}
return "Empty";
}
if (ConsistsOfWhiteSpace(customDimension)) {
return "Empty";
}
return customDimension;
}
private bool ConsistsOfWhiteSpace(string s)
{
foreach (char c in s) {
if (c != ' ')
return false;
}
return true;
}
#endregion
}
}
| 47.421947 | 327 | 0.520822 | [
"MIT"
] | vahaponur/SassyCookies | Assets/GameAnalytics/Editor/GA_SettingsInspector.cs | 133,967 | C# |
using System;
namespace Rx
{
/// <summary>
/// Represents the result of an asynchronous operation.
/// </summary>
[Imported]
public class AsyncSubject : Observable, ISubject
{
/// <summary>
/// Creates a subject that can only receive one value and that value is cached for all future observations.
/// </summary>
[AlternateSignature]
public AsyncSubject(Scheduler scheduler)
{
}
/// <summary>
/// Creates a subject that can only receive one value and that value is cached for all future observations.
/// </summary>
[AlternateSignature]
public AsyncSubject()
{
}
/// <summary>
/// Notifies all subscribed observers with the value.
/// </summary>
[PreserveCase]
public void OnNext(object value)
{
}
/// <summary>
/// Notifies all subscribed observers with the exception.
/// </summary>
[PreserveCase]
public void OnError(object exception)
{
}
/// <summary>
/// Notifies all subscribed observers of the end of the sequence.
/// </summary>
[PreserveCase]
public void OnCompleted()
{
}
}
}
| 24.759259 | 115 | 0.534031 | [
"Apache-2.0"
] | Reactive-Extensions/IL2JS | Reactive/ScriptSharp/AsyncSubject.cs | 1,339 | C# |
using System.Windows;
using System.Windows.Media;
namespace EarTrumpet.Services
{
public class ThemeService
{
public static bool IsWindowTransparencyEnabled
{
get { return !SystemParameters.HighContrast && UserSystemPreferencesService.IsTransparencyEnabled; }
}
public static void UpdateThemeResources(ResourceDictionary dictionary)
{
dictionary["WindowBackground"] = new SolidColorBrush(GetWindowBackgroundColor());
SetBrush(dictionary, "WindowForeground", "ImmersiveApplicationTextDarkTheme");
ReplaceBrush(dictionary, "CottonSwabSliderThumb", "ImmersiveSystemAccent");
ReplaceBrushWithOpacity(dictionary, "HeaderBackground", "ImmersiveSystemAccent", 0.2);
ReplaceBrush(dictionary, "CottonSwabSliderTrackFill", "ImmersiveSystemAccentLight1");
SetBrush(dictionary, "CottonSwabSliderThumbHover", "ImmersiveControlDarkSliderThumbHover");
SetBrush(dictionary, "CottonSwabSliderThumbPressed", "ImmersiveControlDarkSliderThumbHover");
}
private static Color GetWindowBackgroundColor()
{
string resource;
if (SystemParameters.HighContrast)
{
resource = "ImmersiveApplicationBackground";
}
else if (UserSystemPreferencesService.UseAccentColor)
{
resource = IsWindowTransparencyEnabled ? "ImmersiveSystemAccentDark2" : "ImmersiveSystemAccentDark1";
}
else
{
resource = "ImmersiveDarkChromeMedium";
}
var color = AccentColorService.GetColorByTypeName(resource);
color.A = (byte) (IsWindowTransparencyEnabled ? 190 : 255);
return color;
}
private static void SetBrushWithOpacity(ResourceDictionary dictionary, string name, string immersiveAccentName, double opacity)
{
var color = AccentColorService.GetColorByTypeName(immersiveAccentName);
color.A = (byte) (opacity*255);
((SolidColorBrush) dictionary[name]).Color = color;
}
private static void SetBrush(ResourceDictionary dictionary, string name, string immersiveAccentName)
{
SetBrushWithOpacity(dictionary, name, immersiveAccentName, 1.0);
}
private static void ReplaceBrush(ResourceDictionary dictionary, string name, string immersiveAccentName)
{
dictionary[name] = new SolidColorBrush(AccentColorService.GetColorByTypeName(immersiveAccentName));
}
private static void ReplaceBrushWithOpacity(ResourceDictionary dictionary, string name, string immersiveAccentName, double opacity)
{
var color = AccentColorService.GetColorByTypeName(immersiveAccentName);
color.A = (byte)(opacity * 255);
dictionary[name] = new SolidColorBrush(color);
}
}
} | 43.086957 | 139 | 0.667339 | [
"MIT"
] | wolfreak99/EarTrumpet | EarTrumpet/Services/ThemeService.cs | 2,975 | C# |
/*
* Copyright 2010-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the cognito-idp-2016-04-18.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text;
using System.Xml.Serialization;
using Amazon.CognitoIdentityProvider.Model;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Transform;
using Amazon.Runtime.Internal.Util;
using ThirdParty.Json.LitJson;
namespace Amazon.CognitoIdentityProvider.Model.Internal.MarshallTransformations
{
/// <summary>
/// Response Unmarshaller for ListUserPools operation
/// </summary>
public class ListUserPoolsResponseUnmarshaller : JsonResponseUnmarshaller
{
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
ListUserPoolsResponse response = new ListUserPoolsResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("NextToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextToken = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("UserPools", targetDepth))
{
var unmarshaller = new ListUnmarshaller<UserPoolDescriptionType, UserPoolDescriptionTypeUnmarshaller>(UserPoolDescriptionTypeUnmarshaller.Instance);
response.UserPools = unmarshaller.Unmarshall(context);
continue;
}
}
return response;
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
var errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
errorResponse.InnerException = innerException;
errorResponse.StatusCode = statusCode;
var responseBodyBytes = context.GetResponseBodyBytes();
using (var streamCopy = new MemoryStream(responseBodyBytes))
using (var contextCopy = new JsonUnmarshallerContext(streamCopy, false, null))
{
if (errorResponse.Code != null && errorResponse.Code.Equals("InternalErrorException"))
{
return InternalErrorExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse);
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidParameterException"))
{
return InvalidParameterExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse);
}
if (errorResponse.Code != null && errorResponse.Code.Equals("NotAuthorizedException"))
{
return NotAuthorizedExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse);
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyRequestsException"))
{
return TooManyRequestsExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse);
}
}
return new AmazonCognitoIdentityProviderException(errorResponse.Message, errorResponse.InnerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
}
private static ListUserPoolsResponseUnmarshaller _instance = new ListUserPoolsResponseUnmarshaller();
internal static ListUserPoolsResponseUnmarshaller GetInstance()
{
return _instance;
}
/// <summary>
/// Gets the singleton.
/// </summary>
public static ListUserPoolsResponseUnmarshaller Instance
{
get
{
return _instance;
}
}
}
} | 40.632813 | 206 | 0.642953 | [
"Apache-2.0"
] | DetlefGolze/aws-sdk-net | sdk/src/Services/CognitoIdentityProvider/Generated/Model/Internal/MarshallTransformations/ListUserPoolsResponseUnmarshaller.cs | 5,201 | C# |
/*
* Copyright (c) 2018 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
namespace TencentCloud.Live.V20180801.Models
{
using Newtonsoft.Json;
using System.Collections.Generic;
using TencentCloud.Common;
public class DescribeLiveTranscodeRulesResponse : AbstractModel
{
/// <summary>
/// 转码规则列表。
/// </summary>
[JsonProperty("Rules")]
public RuleInfo[] Rules{ get; set; }
/// <summary>
/// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
/// </summary>
[JsonProperty("RequestId")]
public string RequestId{ get; set; }
/// <summary>
/// For internal usage only. DO NOT USE IT.
/// </summary>
public override void ToMap(Dictionary<string, string> map, string prefix)
{
this.SetParamArrayObj(map, prefix + "Rules.", this.Rules);
this.SetParamSimple(map, prefix + "RequestId", this.RequestId);
}
}
}
| 30.529412 | 81 | 0.642903 | [
"Apache-2.0"
] | TencentCloud/tencentcloud-sdk-dotnet | TencentCloud/Live/V20180801/Models/DescribeLiveTranscodeRulesResponse.cs | 1,629 | C# |
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WpfUi.Models;
using WpfUi.ViewModels;
namespace WpfUi.Helpers
{
public class BookListFilter
{
private readonly BookCardViewModel _bookCardViewModel;
private readonly bool _isShowReadBooks;
private readonly string _bookFilterText = string.Empty;
private readonly ObservableCollection<SelectableTagModel> _selectableTagModels;
public BookListFilter(BookCardViewModel bookCardViewModel, bool isShowReadBooks, string bookFilterText, ObservableCollection<SelectableTagModel> selectableTagModels)
{
_bookCardViewModel = bookCardViewModel;
_isShowReadBooks = isShowReadBooks;
_bookFilterText = bookFilterText;
_selectableTagModels = selectableTagModels;
}
public bool IsBookShown()
{
return IsBookShownBasedOnFilterText() && IsBookShownBasedOnTagSelection()
&& IsBookShownBasedOnReadStatus();
}
private bool IsBookShownBasedOnFilterText()
{
return IsFilterTextInBookName() || IsFilterTextInAnyBookTag();
}
private bool IsFilterTextInBookName()
{
bool output = _bookCardViewModel.BookName.Contains(_bookFilterText, StringComparison.InvariantCultureIgnoreCase);
return output;
}
private bool IsFilterTextInAnyBookTag()
{
bool output = _bookCardViewModel.Tags.Any(x => x.Contains(_bookFilterText, StringComparison.InvariantCultureIgnoreCase));
return output;
}
private bool IsBookShownBasedOnTagSelection()
{
List<SelectableTagModel> selectedTags = GetSelectedTags();
if (selectedTags.Count == 0)
{
return true;
}
else
{
return DoesBookHaveAllSelectedTags(selectedTags);
}
}
private List<SelectableTagModel> GetSelectedTags()
{
return _selectableTagModels.Where(x => x.IsSelected).ToList();
}
private bool DoesBookHaveAllSelectedTags(List<SelectableTagModel> selectedTags)
{
ObservableCollection<string> bookTags = _bookCardViewModel.Tags;
List<string> selectedTagNames = selectedTags.Select(x => x.Tag).ToList();
bool doesBookHaveAllSelectedTags = selectedTagNames.All(tagName => bookTags.Contains(tagName));
return doesBookHaveAllSelectedTags;
}
private bool IsBookShownBasedOnReadStatus()
{
bool isBookShown;
if (_isShowReadBooks == true)
{
isBookShown = true;
}
else
{
if (_bookCardViewModel.IsRead)
{
isBookShown = false;
}
else
{
isBookShown = true;
}
}
return isBookShown;
}
}
}
| 27.094737 | 167 | 0.757964 | [
"MIT"
] | basaif/ReadingChecklist | WpfUi/Helpers/BookListFilter.cs | 2,576 | C# |
using System;
namespace Magnesium.Vulkan
{
internal enum VkPipelineCacheHeaderVersion : uint
{
PipelineCacheHeaderVersionOne = 1,
}
}
| 14 | 50 | 0.778571 | [
"MIT"
] | tgsstdio/Mg | Magnesium.Vulkan/Enums/VkPipelineCacheHeaderVersion.cs | 140 | C# |
// ===========
// DO NOT EDIT - this file is automatically regenerated.
// ===========
using System.Collections.Generic;
using Unity.Entities;
namespace Improbable.Gdk.Tests.NonblittableTypes
{
public partial class NonBlittableComponent
{
public class CommandSenders
{
public struct FirstCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.FirstCommand.Request> RequestsToSend
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandSenderProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandSenderProvider.Set(CommandListHandle, value);
}
}
public struct SecondCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.SecondCommand.Request> RequestsToSend
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandSenderProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandSenderProvider.Set(CommandListHandle, value);
}
}
}
public class CommandRequests
{
public struct FirstCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.FirstCommand.ReceivedRequest> Requests
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandRequestsProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandRequestsProvider.Set(CommandListHandle, value);
}
}
public struct SecondCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.SecondCommand.ReceivedRequest> Requests
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandRequestsProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandRequestsProvider.Set(CommandListHandle, value);
}
}
}
public class CommandResponders
{
public struct FirstCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.FirstCommand.Response> ResponsesToSend
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandResponderProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandResponderProvider.Set(CommandListHandle, value);
}
}
public struct SecondCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.SecondCommand.Response> ResponsesToSend
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandResponderProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandResponderProvider.Set(CommandListHandle, value);
}
}
}
public class CommandResponses
{
public struct FirstCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.FirstCommand.ReceivedResponse> Responses
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandResponsesProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.FirstCommandResponsesProvider.Set(CommandListHandle, value);
}
}
public struct SecondCommand : IComponentData
{
internal uint CommandListHandle;
public List<Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.SecondCommand.ReceivedResponse> Responses
{
get => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandResponsesProvider.Get(CommandListHandle);
set => Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.SecondCommandResponsesProvider.Set(CommandListHandle, value);
}
}
}
}
}
| 55.069307 | 172 | 0.672959 | [
"MIT"
] | filod/gdk-for-unity | test-project/Assets/Generated/Source/improbable/gdk/tests/nonblittabletypes/NonBlittableComponentCommandComponents.cs | 5,562 | C# |
using Lucene.Net.Analysis;
using Lucene.Net.Analysis.TokenAttributes;
using Lucene.Net.QueryParsers.Flexible.Core.Nodes;
using Lucene.Net.QueryParsers.Flexible.Core.Processors;
using Lucene.Net.QueryParsers.Flexible.Standard.Config;
using Lucene.Net.QueryParsers.Flexible.Standard.Nodes;
using Lucene.Net.Support;
using Lucene.Net.Util;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using Operator = Lucene.Net.QueryParsers.Flexible.Standard.Config.StandardQueryConfigHandler.Operator;
namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
{
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/// <summary>
/// This processor verifies if <see cref="ConfigurationKeys.ANALYZER"/>
/// is defined in the <see cref="Core.Config.QueryConfigHandler"/>. If it is and the analyzer is
/// not <c>null</c>, it looks for every <see cref="FieldQueryNode"/> that is not
/// <see cref="WildcardQueryNode"/>, <see cref="FuzzyQueryNode"/> or
/// <see cref="IRangeQueryNode"/> contained in the query node tree, then it applies
/// the analyzer to that <see cref="FieldQueryNode"/> object.
/// <para/>
/// If the analyzer return only one term, the returned term is set to the
/// <see cref="FieldQueryNode"/> and it's returned.
/// <para/>
/// If the analyzer return more than one term, a <see cref="TokenizedPhraseQueryNode"/>
/// or <see cref="MultiPhraseQueryNode"/> is created, whether there is one or more
/// terms at the same position, and it's returned.
/// <para/>
/// If no term is returned by the analyzer a <see cref="NoTokenFoundQueryNode"/> object
/// is returned.
/// </summary>
/// <seealso cref="ConfigurationKeys.ANALYZER"/>
/// <seealso cref="Analyzer"/>
/// <seealso cref="TokenStream"/>
public class AnalyzerQueryNodeProcessor : QueryNodeProcessor
{
private Analyzer analyzer;
private bool positionIncrementsEnabled;
private Operator defaultOperator;
public AnalyzerQueryNodeProcessor()
{
// empty constructor
}
public override IQueryNode Process(IQueryNode queryTree)
{
Analyzer analyzer = GetQueryConfigHandler().Get(ConfigurationKeys.ANALYZER);
if (analyzer != null)
{
this.analyzer = analyzer;
this.positionIncrementsEnabled = false;
bool? positionIncrementsEnabled = GetQueryConfigHandler().Get(ConfigurationKeys.ENABLE_POSITION_INCREMENTS);
// LUCENENET specific - rather than using null, we are relying on the behavior that the default
// value for an enum is 0 (OR in this case).
//var defaultOperator = GetQueryConfigHandler().Get(ConfigurationKeys.DEFAULT_OPERATOR);
//this.defaultOperator = defaultOperator != null ? defaultOperator.Value : Operator.OR;
this.defaultOperator = GetQueryConfigHandler().Get(ConfigurationKeys.DEFAULT_OPERATOR);
if (positionIncrementsEnabled != null)
{
this.positionIncrementsEnabled = positionIncrementsEnabled.Value;
}
if (this.analyzer != null)
{
return base.Process(queryTree);
}
}
return queryTree;
}
protected override IQueryNode PostProcessNode(IQueryNode node)
{
if (node is ITextableQueryNode
&& !(node is WildcardQueryNode)
&& !(node is FuzzyQueryNode)
&& !(node is RegexpQueryNode)
&& !(node.Parent is IRangeQueryNode))
{
FieldQueryNode fieldNode = ((FieldQueryNode)node);
string text = fieldNode.GetTextAsString();
string field = fieldNode.GetFieldAsString();
CachingTokenFilter buffer = null;
IPositionIncrementAttribute posIncrAtt = null;
int numTokens = 0;
int positionCount = 0;
bool severalTokensAtSamePosition = false;
TokenStream source = null;
try
{
source = this.analyzer.GetTokenStream(field, text);
source.Reset();
buffer = new CachingTokenFilter(source);
if (buffer.HasAttribute<IPositionIncrementAttribute>())
{
posIncrAtt = buffer.GetAttribute<IPositionIncrementAttribute>();
}
try
{
while (buffer.IncrementToken())
{
numTokens++;
int positionIncrement = (posIncrAtt != null) ? posIncrAtt
.PositionIncrement : 1;
if (positionIncrement != 0)
{
positionCount += positionIncrement;
}
else
{
severalTokensAtSamePosition = true;
}
}
}
#pragma warning disable 168
catch (IOException e)
#pragma warning restore 168
{
// ignore
}
}
catch (IOException e)
{
throw new Exception(e.ToString(), e);
}
finally
{
IOUtils.DisposeWhileHandlingException(source);
}
// rewind the buffer stream
buffer.Reset();
if (!buffer.HasAttribute<ICharTermAttribute>())
{
return new NoTokenFoundQueryNode();
}
ICharTermAttribute termAtt = buffer.GetAttribute<ICharTermAttribute>();
if (numTokens == 0)
{
return new NoTokenFoundQueryNode();
}
else if (numTokens == 1)
{
string term = null;
try
{
bool hasNext;
hasNext = buffer.IncrementToken();
Debug.Assert(hasNext == true);
term = termAtt.ToString();
}
#pragma warning disable 168
catch (IOException e)
#pragma warning restore 168
{
// safe to ignore, because we know the number of tokens
}
fieldNode.Text = term.ToCharSequence();
return fieldNode;
}
else if (severalTokensAtSamePosition || !(node is QuotedFieldQueryNode))
{
if (positionCount == 1 || !(node is QuotedFieldQueryNode))
{
// no phrase query:
if (positionCount == 1)
{
// simple case: only one position, with synonyms
List<IQueryNode> children = new List<IQueryNode>();
for (int i = 0; i < numTokens; i++)
{
string term = null;
try
{
bool hasNext = buffer.IncrementToken();
Debug.Assert(hasNext == true);
term = termAtt.ToString();
}
#pragma warning disable 168
catch (IOException e)
#pragma warning restore 168
{
// safe to ignore, because we know the number of tokens
}
children.Add(new FieldQueryNode(field, term, -1, -1));
}
return new GroupQueryNode(
new StandardBooleanQueryNode(children, positionCount == 1));
}
else
{
// multiple positions
IQueryNode q = new StandardBooleanQueryNode(new List<IQueryNode>(), false);
IQueryNode currentQuery = null;
for (int i = 0; i < numTokens; i++)
{
string term = null;
try
{
bool hasNext = buffer.IncrementToken();
Debug.Assert(hasNext == true);
term = termAtt.ToString();
}
#pragma warning disable 168
catch (IOException e)
#pragma warning restore 168
{
// safe to ignore, because we know the number of tokens
}
if (posIncrAtt != null && posIncrAtt.PositionIncrement == 0)
{
if (!(currentQuery is BooleanQueryNode))
{
IQueryNode t = currentQuery;
currentQuery = new StandardBooleanQueryNode(new List<IQueryNode>(), true);
((BooleanQueryNode)currentQuery).Add(t);
}
((BooleanQueryNode)currentQuery).Add(new FieldQueryNode(field, term, -1, -1));
}
else
{
if (currentQuery != null)
{
if (this.defaultOperator == Operator.OR)
{
q.Add(currentQuery);
}
else
{
q.Add(new ModifierQueryNode(currentQuery, Modifier.MOD_REQ));
}
}
currentQuery = new FieldQueryNode(field, term, -1, -1);
}
}
if (this.defaultOperator == Operator.OR)
{
q.Add(currentQuery);
}
else
{
q.Add(new ModifierQueryNode(currentQuery, Modifier.MOD_REQ));
}
if (q is BooleanQueryNode)
{
q = new GroupQueryNode(q);
}
return q;
}
}
else
{
// phrase query:
MultiPhraseQueryNode mpq = new MultiPhraseQueryNode();
List<FieldQueryNode> multiTerms = new List<FieldQueryNode>();
int position = -1;
int i = 0;
int termGroupCount = 0;
for (; i < numTokens; i++)
{
string term = null;
int positionIncrement = 1;
try
{
bool hasNext = buffer.IncrementToken();
Debug.Assert(hasNext == true);
term = termAtt.ToString();
if (posIncrAtt != null)
{
positionIncrement = posIncrAtt.PositionIncrement;
}
}
#pragma warning disable 168
catch (IOException e)
#pragma warning restore 168
{
// safe to ignore, because we know the number of tokens
}
if (positionIncrement > 0 && multiTerms.Count > 0)
{
foreach (FieldQueryNode termNode in multiTerms)
{
if (this.positionIncrementsEnabled)
{
termNode.PositionIncrement = position;
}
else
{
termNode.PositionIncrement = termGroupCount;
}
mpq.Add(termNode);
}
// Only increment once for each "group" of
// terms that were in the same position:
termGroupCount++;
multiTerms.Clear();
}
position += positionIncrement;
multiTerms.Add(new FieldQueryNode(field, term, -1, -1));
}
foreach (FieldQueryNode termNode in multiTerms)
{
if (this.positionIncrementsEnabled)
{
termNode.PositionIncrement = position;
}
else
{
termNode.PositionIncrement = termGroupCount;
}
mpq.Add(termNode);
}
return mpq;
}
}
else
{
TokenizedPhraseQueryNode pq = new TokenizedPhraseQueryNode();
int position = -1;
for (int i = 0; i < numTokens; i++)
{
string term = null;
int positionIncrement = 1;
try
{
bool hasNext = buffer.IncrementToken();
Debug.Assert(hasNext == true);
term = termAtt.ToString();
if (posIncrAtt != null)
{
positionIncrement = posIncrAtt.PositionIncrement;
}
}
#pragma warning disable 168
catch (IOException e)
#pragma warning restore 168
{
// safe to ignore, because we know the number of tokens
}
FieldQueryNode newFieldNode = new FieldQueryNode(field, term, -1, -1);
if (this.positionIncrementsEnabled)
{
position += positionIncrement;
newFieldNode.PositionIncrement = position;
}
else
{
newFieldNode.PositionIncrement = i;
}
pq.Add(newFieldNode);
}
return pq;
}
}
return node;
}
protected override IQueryNode PreProcessNode(IQueryNode node)
{
return node;
}
protected override IList<IQueryNode> SetChildrenOrder(IList<IQueryNode> children)
{
return children;
}
}
}
| 40.883178 | 124 | 0.420791 | [
"Apache-2.0"
] | DiogenesPolanco/lucenenet | src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs | 17,500 | C# |
// ------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT License. See License in the project root for license information.
// ------------------------------------------------------------------------------
// **NOTE** This file was generated by a tool and any changes will be overwritten.
// <auto-generated/>
// Template Source: EntityCollectionRequestBuilder.cs.tt
namespace Microsoft.Graph
{
using System;
using System.Collections.Generic;
/// <summary>
/// The type DeviceConfigurationAssignmentsCollectionRequestBuilder.
/// </summary>
public partial class DeviceConfigurationAssignmentsCollectionRequestBuilder : BaseRequestBuilder, IDeviceConfigurationAssignmentsCollectionRequestBuilder
{
/// <summary>
/// Constructs a new DeviceConfigurationAssignmentsCollectionRequestBuilder.
/// </summary>
/// <param name="requestUrl">The URL for the built request.</param>
/// <param name="client">The <see cref="IBaseClient"/> for handling requests.</param>
public DeviceConfigurationAssignmentsCollectionRequestBuilder(
string requestUrl,
IBaseClient client)
: base(requestUrl, client)
{
}
/// <summary>
/// Builds the request.
/// </summary>
/// <returns>The built request.</returns>
public IDeviceConfigurationAssignmentsCollectionRequest Request()
{
return this.Request(null);
}
/// <summary>
/// Builds the request.
/// </summary>
/// <param name="options">The query and header options for the request.</param>
/// <returns>The built request.</returns>
public IDeviceConfigurationAssignmentsCollectionRequest Request(IEnumerable<Option> options)
{
return new DeviceConfigurationAssignmentsCollectionRequest(this.RequestUrl, this.Client, options);
}
/// <summary>
/// Gets an <see cref="IDeviceConfigurationAssignmentRequestBuilder"/> for the specified DeviceConfigurationDeviceConfigurationAssignment.
/// </summary>
/// <param name="id">The ID for the DeviceConfigurationDeviceConfigurationAssignment.</param>
/// <returns>The <see cref="IDeviceConfigurationAssignmentRequestBuilder"/>.</returns>
public IDeviceConfigurationAssignmentRequestBuilder this[string id]
{
get
{
return new DeviceConfigurationAssignmentRequestBuilder(this.AppendSegmentToRequestUrl(id), this.Client);
}
}
}
}
| 41.075758 | 157 | 0.624493 | [
"MIT"
] | Aliases/msgraph-sdk-dotnet | src/Microsoft.Graph/Generated/requests/DeviceConfigurationAssignmentsCollectionRequestBuilder.cs | 2,711 | C# |
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
namespace Microsoft.Azure.Devices.Common
{
using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
#if NET451
using System.Transactions;
#endif
using Microsoft.Azure.Devices.Common.Tracing;
// AsyncResult starts acquired; Complete releases.
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.ManualResetEvent, SupportsAsync = true, ReleaseMethod = "Complete")]
[DebuggerStepThrough]
[SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable",
Justification = "Uses custom scheme for cleanup")]
abstract class AsyncResult : IAsyncResult
{
public const string DisablePrepareForRethrow = "DisablePrepareForRethrow";
static AsyncCallback asyncCompletionWrapperCallback;
AsyncCallback callback;
bool completedSynchronously;
bool endCalled;
Exception exception;
bool isCompleted;
AsyncCompletion nextAsyncCompletion;
#if NET451
IAsyncResult deferredTransactionalResult;
TransactionSignalScope transactionContext;
#endif
object state;
[Fx.Tag.SynchronizationObject]
ManualResetEvent manualResetEvent;
[Fx.Tag.SynchronizationObject(Blocking = false)]
object thisLock;
#if DEBUG
UncompletedAsyncResultMarker marker;
#endif
protected AsyncResult(AsyncCallback callback, object state)
{
this.callback = callback;
this.state = state;
this.thisLock = new object();
#if DEBUG
this.marker = new UncompletedAsyncResultMarker(this);
#endif
}
public object AsyncState
{
get
{
return this.state;
}
}
public WaitHandle AsyncWaitHandle
{
get
{
if (this.manualResetEvent != null)
{
return this.manualResetEvent;
}
lock (this.ThisLock)
{
if (this.manualResetEvent == null)
{
this.manualResetEvent = new ManualResetEvent(isCompleted);
}
}
return this.manualResetEvent;
}
}
public bool CompletedSynchronously
{
get
{
return this.completedSynchronously;
}
}
public bool HasCallback
{
get
{
return this.callback != null;
}
}
public bool IsCompleted
{
get
{
return this.isCompleted;
}
}
// used in conjunction with PrepareAsyncCompletion to allow for finally blocks
protected Action<AsyncResult, Exception> OnCompleting { get; set; }
// Override this property to provide the ActivityId when completing with exception
protected internal virtual EventTraceActivity Activity
{
get { return null; }
}
#if NET451
// Override this property to change the trace level when completing with exception
protected virtual TraceEventType TraceEventType
{
get { return TraceEventType.Verbose; }
}
#endif
protected object ThisLock
{
get
{
return this.thisLock;
}
}
// subclasses like TraceAsyncResult can use this to wrap the callback functionality in a scope
protected Action<AsyncCallback, IAsyncResult> VirtualCallback
{
get;
set;
}
protected bool TryComplete(bool didCompleteSynchronously, Exception exception)
{
lock (this.ThisLock)
{
if (this.isCompleted)
{
return false;
}
this.exception = exception;
this.isCompleted = true;
}
#if DEBUG
this.marker.AsyncResult = null;
this.marker = null;
#endif
this.completedSynchronously = didCompleteSynchronously;
if (this.OnCompleting != null)
{
// Allow exception replacement, like a catch/throw pattern.
try
{
this.OnCompleting(this, this.exception);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.exception = e;
}
}
if (didCompleteSynchronously)
{
// If we completedSynchronously, then there's no chance that the manualResetEvent was created so
// we don't need to worry about a race
Fx.Assert(this.manualResetEvent == null, "No ManualResetEvent should be created for a synchronous AsyncResult.");
}
else
{
lock (this.ThisLock)
{
if (this.manualResetEvent != null)
{
this.manualResetEvent.Set();
}
}
}
if (this.callback != null)
{
try
{
if (this.VirtualCallback != null)
{
this.VirtualCallback(this.callback, this);
}
else
{
this.callback(this);
}
}
#pragma warning disable 1634
#pragma warning suppress 56500 // transferring exception to another thread
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
throw Fx.Exception.AsError(new CallbackException(CommonResources.AsyncCallbackThrewException, e));
}
#pragma warning restore 1634
}
return true;
}
protected bool TryComplete(bool didcompleteSynchronously)
{
return this.TryComplete(didcompleteSynchronously, null);
}
protected void Complete(bool didCompleteSynchronously)
{
this.Complete(didCompleteSynchronously, null);
}
protected void Complete(bool didCompleteSynchronously, Exception e)
{
if (!this.TryComplete(didCompleteSynchronously, e))
{
throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.GetString(CommonResources.AsyncResultCompletedTwice, this.GetType())));
}
}
static void AsyncCompletionWrapperCallback(IAsyncResult result)
{
if (result == null)
{
throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.InvalidNullAsyncResult));
}
if (result.CompletedSynchronously)
{
return;
}
AsyncResult thisPtr = (AsyncResult)result.AsyncState;
#if NET451
if (thisPtr.transactionContext != null && !thisPtr.transactionContext.Signal(result))
{
// The TransactionScope isn't cleaned up yet and can't be done on this thread. Must defer
// the callback (which is likely to attempt to commit the transaction) until later.
return;
}
#endif
AsyncCompletion callback = thisPtr.GetNextCompletion();
if (callback == null)
{
ThrowInvalidAsyncResult(result);
}
bool completeSelf = false;
Exception completionException = null;
try
{
completeSelf = callback(result);
}
catch (Exception e)
{
completeSelf = true;
completionException = e;
}
if (completeSelf)
{
thisPtr.Complete(false, completionException);
}
}
protected AsyncCallback PrepareAsyncCompletion(AsyncCompletion callback)
{
#if NET451
if (this.transactionContext != null)
{
// It might be an old, leftover one, if an exception was thrown within the last using (PrepareTransactionalCall()) block.
if (this.transactionContext.IsPotentiallyAbandoned)
{
this.transactionContext = null;
}
else
{
this.transactionContext.Prepared();
}
}
#endif
this.nextAsyncCompletion = callback;
if (AsyncResult.asyncCompletionWrapperCallback == null)
{
AsyncResult.asyncCompletionWrapperCallback = new AsyncCallback(AsyncCompletionWrapperCallback);
}
return AsyncResult.asyncCompletionWrapperCallback;
}
protected bool CheckSyncContinue(IAsyncResult result)
{
AsyncCompletion dummy;
return TryContinueHelper(result, out dummy);
}
protected bool SyncContinue(IAsyncResult result)
{
AsyncCompletion callback;
if (TryContinueHelper(result, out callback))
{
return callback(result);
}
else
{
return false;
}
}
bool TryContinueHelper(IAsyncResult result, out AsyncCompletion callback)
{
if (result == null)
{
throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.InvalidNullAsyncResult));
}
callback = null;
if (result.CompletedSynchronously)
{
#if NET451
// Once we pass the check, we know that we own forward progress, so transactionContext is correct. Verify its state.
if (this.transactionContext != null)
{
if (this.transactionContext.State != TransactionSignalState.Completed)
{
ThrowInvalidAsyncResult("Check/SyncContinue cannot be called from within the PrepareTransactionalCall using block.");
}
else if (this.transactionContext.IsSignalled)
{
// This is most likely to happen when result.CompletedSynchronously registers differently here and in the callback, which
// is the fault of 'result'.
ThrowInvalidAsyncResult(result);
}
}
#endif
}
#if NET451
else if (object.ReferenceEquals(result, this.deferredTransactionalResult))
{
// The transactionContext may not be current if forward progress has been made via the callback. Instead,
// use deferredTransactionalResult to see if we are supposed to execute a post-transaction callback.
//
// Once we pass the check, we know that we own forward progress, so transactionContext is correct. Verify its state.
if (this.transactionContext == null || !this.transactionContext.IsSignalled)
{
ThrowInvalidAsyncResult(result);
}
this.deferredTransactionalResult = null;
}
#endif
else
{
return false;
}
callback = GetNextCompletion();
if (callback == null)
{
ThrowInvalidAsyncResult("Only call Check/SyncContinue once per async operation (once per PrepareAsyncCompletion).");
}
return true;
}
AsyncCompletion GetNextCompletion()
{
AsyncCompletion result = this.nextAsyncCompletion;
#if NET451
this.transactionContext = null;
#endif
this.nextAsyncCompletion = null;
return result;
}
protected static void ThrowInvalidAsyncResult(IAsyncResult result)
{
throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.GetString(CommonResources.InvalidAsyncResultImplementation, result.GetType())));
}
protected static void ThrowInvalidAsyncResult(string debugText)
{
string message = CommonResources.InvalidAsyncResultImplementationGeneric;
if (debugText != null)
{
#if DEBUG
message += " " + debugText;
#endif
}
throw Fx.Exception.AsError(new InvalidOperationException(message));
}
[Fx.Tag.Blocking(Conditional = "!asyncResult.isCompleted")]
protected static TAsyncResult End<TAsyncResult>(IAsyncResult result)
where TAsyncResult : AsyncResult
{
if (result == null)
{
throw Fx.Exception.ArgumentNull("result");
}
TAsyncResult asyncResult = result as TAsyncResult;
if (asyncResult == null)
{
throw Fx.Exception.Argument("result", CommonResources.InvalidAsyncResult);
}
if (asyncResult.endCalled)
{
throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.AsyncResultAlreadyEnded));
}
asyncResult.endCalled = true;
if (!asyncResult.isCompleted)
{
lock (asyncResult.ThisLock)
{
if (!asyncResult.isCompleted && asyncResult.manualResetEvent == null)
{
asyncResult.manualResetEvent = new ManualResetEvent(asyncResult.isCompleted);
}
}
}
if (asyncResult.manualResetEvent != null)
{
asyncResult.manualResetEvent.WaitOne();
#if NET451
asyncResult.manualResetEvent.Close();
#else
asyncResult.manualResetEvent.Dispose();
#endif
}
if (asyncResult.exception != null)
{
// Trace before PrepareForRethrow to avoid weird callstack strings
#if NET451
Fx.Exception.TraceException(asyncResult.exception, asyncResult.TraceEventType, asyncResult.Activity);
#else
Fx.Exception.TraceException(asyncResult.exception, TraceEventType.Verbose, asyncResult.Activity);
#endif
ExceptionDispatcher.Throw(asyncResult.exception);
}
return asyncResult;
}
enum TransactionSignalState
{
Ready = 0,
Prepared,
Completed,
Abandoned,
}
#if NET451
[Serializable]
class TransactionSignalScope : SignalGate<IAsyncResult>, IDisposable
{
[NonSerialized]
TransactionScope transactionScope;
[NonSerialized]
AsyncResult parent;
bool disposed;
public TransactionSignalScope(AsyncResult result, Transaction transaction)
{
Fx.Assert(transaction != null, "Null Transaction provided to AsyncResult.TransactionSignalScope.");
this.parent = result;
this.transactionScope = Fx.CreateTransactionScope(transaction);
}
public TransactionSignalState State { get; private set; }
public bool IsPotentiallyAbandoned
{
get
{
return this.State == TransactionSignalState.Abandoned || (State == TransactionSignalState.Completed && !IsSignalled);
}
}
public void Prepared()
{
if (State != TransactionSignalState.Ready)
{
AsyncResult.ThrowInvalidAsyncResult("PrepareAsyncCompletion should only be called once per PrepareTransactionalCall.");
}
this.State = TransactionSignalState.Prepared;
}
protected virtual void Dispose(bool disposing)
{
if (disposing && !this.disposed)
{
this.disposed = true;
if (this.State == TransactionSignalState.Ready)
{
this.State = TransactionSignalState.Abandoned;
}
else if (this.State == TransactionSignalState.Prepared)
{
this.State = TransactionSignalState.Completed;
}
else
{
AsyncResult.ThrowInvalidAsyncResult("PrepareTransactionalCall should only be called in a using. Dispose called multiple times.");
}
try
{
Fx.CompleteTransactionScope(ref this.transactionScope);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
// Complete and Dispose are not expected to throw. If they do it can mess up the AsyncResult state machine.
throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.AsyncTransactionException));
}
// This will release the callback to run, or tell us that we need to defer the callback to Check/SyncContinue.
//
// It's possible to avoid this Interlocked when CompletedSynchronously is true, but we have no way of knowing that
// from here, and adding a way would add complexity to the AsyncResult transactional calling pattern. This
// unnecessary Interlocked only happens when: PrepareTransactionalCall is called with a non-null transaction,
// PrepareAsyncCompletion is reached, and the operation completes synchronously or with an exception.
IAsyncResult result;
if (this.State == TransactionSignalState.Completed && Unlock(out result))
{
if (this.parent.deferredTransactionalResult != null)
{
AsyncResult.ThrowInvalidAsyncResult(this.parent.deferredTransactionalResult);
}
this.parent.deferredTransactionalResult = result;
}
}
}
void IDisposable.Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
#endif
// can be utilized by subclasses to write core completion code for both the sync and async paths
// in one location, signalling chainable synchronous completion with the boolean result,
// and leveraging PrepareAsyncCompletion for conversion to an AsyncCallback.
// NOTE: requires that "this" is passed in as the state object to the asynchronous sub-call being used with a completion routine.
protected delegate bool AsyncCompletion(IAsyncResult result);
#if DEBUG
class UncompletedAsyncResultMarker
{
public UncompletedAsyncResultMarker(AsyncResult result)
{
AsyncResult = result;
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Debug-only facility")]
public AsyncResult AsyncResult { get; set; }
}
#endif
}
// Use this as your base class for AsyncResult and you don't have to define the End method.
abstract class AsyncResult<TAsyncResult> : AsyncResult
where TAsyncResult : AsyncResult<TAsyncResult>
{
protected AsyncResult(AsyncCallback callback, object state)
: base(callback, state)
{
}
public static TAsyncResult End(IAsyncResult asyncResult)
{
return AsyncResult.End<TAsyncResult>(asyncResult);
}
}
}
| 34.11293 | 165 | 0.543684 | [
"MIT"
] | CIPop-test/azure-iot-sdk-csharp | iothub/service/src/Common/AsyncResult.cs | 20,843 | C# |
// Copyright © Tanner Gooding and Contributors. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
// Ported from um/winioctl.h in the Windows SDK for Windows 10.0.22000.0
// Original source is Copyright © Microsoft. All rights reserved.
namespace TerraFX.Interop.Windows;
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS"]/*' />
public enum STORAGE_DISK_OPERATIONAL_STATUS
{
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusNone"]/*' />
DiskOpStatusNone = 0,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusUnknown"]/*' />
DiskOpStatusUnknown,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusOk"]/*' />
DiskOpStatusOk,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusPredictingFailure"]/*' />
DiskOpStatusPredictingFailure,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusInService"]/*' />
DiskOpStatusInService,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusHardwareError"]/*' />
DiskOpStatusHardwareError,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusNotUsable"]/*' />
DiskOpStatusNotUsable,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusTransientError"]/*' />
DiskOpStatusTransientError,
/// <include file='STORAGE_DISK_OPERATIONAL_STATUS.xml' path='doc/member[@name="STORAGE_DISK_OPERATIONAL_STATUS.DiskOpStatusMissing"]/*' />
DiskOpStatusMissing,
}
| 54.263158 | 153 | 0.777401 | [
"MIT"
] | reflectronic/terrafx.interop.windows | sources/Interop/Windows/Windows/um/winioctl/STORAGE_DISK_OPERATIONAL_STATUS.cs | 2,064 | C# |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class InstancedColor : MonoBehaviour
{
[SerializeField]
private Color color = Color.white;
static MaterialPropertyBlock propertyBlock;
static int colorID = Shader.PropertyToID("_Color");
void Start()
{
}
private void OnValidate()
{
if (propertyBlock == null)
propertyBlock = new MaterialPropertyBlock();
propertyBlock.SetColor(colorID, color);
GetComponent<MeshRenderer>().SetPropertyBlock(propertyBlock);
}
}
| 23.08 | 69 | 0.689775 | [
"MIT"
] | Kasugalex/KasugRenderPipeline | Assets/2.CatlikeSRP/2.CustomShader/Scripts/InstancedColor.cs | 579 | C# |
namespace UAlbion.Formats.AssetIds
{
public enum TacticId // TODO: Add this info to a JSON file and then auto-generate the enum.
{
Unknown0 = 0,
Unknown1 = 1,
Unknown2 = 2,
Unknown3 = 3,
Unknown4 = 4,
Unknown5 = 5,
Unknown6 = 6,
Unknown7 = 7,
Unknown8 = 8,
Unknown9 = 9,
Unknown10 = 10,
Unknown11 = 11,
Unknown12 = 12,
Unknown13 = 13,
Unknown14 = 14,
Unknown15 = 15,
Unknown16 = 16,
Unknown17 = 17,
Unknown18 = 18,
Unknown19 = 19,
Unknown20 = 20,
Unknown21 = 21,
Unknown22 = 22,
Unknown23 = 23,
Unknown24 = 24,
Unknown25 = 25,
Unknown26 = 26,
Unknown27 = 27,
Unknown28 = 28,
Unknown29 = 29,
Unknown30 = 30,
Unknown31 = 31,
Unknown32 = 32,
Unknown33 = 33,
Unknown34 = 34,
Unknown35 = 35,
Unknown36 = 36,
Unknown37 = 37,
Unknown38 = 38,
Unknown39 = 39,
Unknown40 = 40,
Unknown41 = 41,
Unknown42 = 42,
Unknown43 = 43,
Unknown44 = 44,
Unknown45 = 45,
Unknown46 = 46,
Unknown47 = 47,
Unknown48 = 48,
Unknown49 = 49,
Unknown50 = 50,
Unknown51 = 51,
Unknown52 = 52,
Unknown53 = 53,
Unknown54 = 54,
Unknown55 = 55,
Unknown56 = 56,
Unknown57 = 57,
Unknown58 = 58,
Unknown59 = 59,
Unknown60 = 60,
Unknown61 = 61,
Unknown62 = 62,
Unknown63 = 63,
Unknown64 = 64,
Unknown65 = 65,
Unknown66 = 66,
Unknown67 = 67,
Unknown68 = 68,
Unknown69 = 69,
Unknown70 = 70,
Unknown71 = 71,
}
} | 23.769231 | 95 | 0.470874 | [
"MIT"
] | mrwillbarnz/ualbion | Formats/AssetIds/TacticId.cs | 1,854 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("RenaultCodeRadio")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RenaultCodeRadio")]
[assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: ComVisible(false)] | 36.137931 | 84 | 0.744275 | [
"MIT"
] | joaodfmota/RenaultCodeRadio | windows/RenaultCodeRadio/Properties/AssemblyInfo.cs | 1,049 | C# |
// *****************************************************************************
// BSD 3-Clause License (https://github.com/ComponentFactory/Krypton/blob/master/LICENSE)
// © Component Factory Pty Ltd, 2006 - 2016, All rights reserved.
// The software and associated documentation supplied hereunder are the
// proprietary information of Component Factory Pty Ltd, 13 Swallows Close,
// Mornington, Vic 3931, Australia and are supplied subject to license terms.
//
// Modifications by Peter Wagner(aka Wagnerp) & Simon Coghlan(aka Smurf-IV) 2017 - 2020. All rights reserved. (https://github.com/Wagnerp/Krypton-NET-5.490)
// Version 5.490.0.0 www.ComponentFactory.com
// *****************************************************************************
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Diagnostics;
using System.Reflection;
namespace Krypton.Toolkit
{
/// <summary>
/// View element that can draw a content
/// </summary>
public class ViewDrawContent : ViewLeaf
{
#region Static Fields
private static PropertyInfo _pi = null;
#endregion
#region Instance Fields
internal IPaletteContent _paletteContent;
private IDisposable _memento;
#endregion
#region Identity
/// <summary>
/// Initialize a new instance of the ViewDrawContent class.
/// </summary>
/// <param name="paletteContent">Palette source for the content.</param>
/// <param name="values">Reference to actual content values.</param>
/// <param name="orientation">Visual orientation of the content.</param>
public ViewDrawContent(IPaletteContent paletteContent,
IContentValues values,
VisualOrientation orientation)
{
// Cache the starting values
_paletteContent = paletteContent;
Values = values;
Orientation = orientation;
// Default other state
DrawContentOnComposition = false;
Glowing = false;
TestForFocusCues = false;
}
/// <summary>
/// Initialize a new instance of the ViewDrawContent class.
/// </summary>
/// <param name="paletteContent">Palette source for the content.</param>
/// <param name="values">Reference to actual content values.</param>
/// <param name="orientation">Visual orientation of the content.</param>
/// <param name="composition">Draw on composition.</param>
/// <param name="glowing">If composition, should glowing be drawn.</param>
public ViewDrawContent(IPaletteContent paletteContent,
IContentValues values,
VisualOrientation orientation,
bool composition,
bool glowing)
{
// Cache the starting values
_paletteContent = paletteContent;
Values = values;
Orientation = orientation;
// Default other state
DrawContentOnComposition = composition;
Glowing = glowing;
TestForFocusCues = false;
}
/// <summary>
/// Obtains the String representation of this instance.
/// </summary>
/// <returns>User readable name of the instance.</returns>
public override string ToString()
{
// Return the class name and instance identifier
return "ViewDrawContent:" + Id;
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
// Dispose of old memento first
if (_memento != null)
{
_memento.Dispose();
_memento = null;
}
}
base.Dispose(disposing);
}
#endregion
#region DrawContentOnComposition
/// <summary>
/// Gets and sets the composition value.
/// </summary>
public bool DrawContentOnComposition { get; set; }
#endregion
#region Glowing
/// <summary>
/// Gets ans sets the glowing value.
/// </summary>
public bool Glowing { get; set; }
#endregion
#region TestForFocusCues
/// <summary>
/// Gets and sets the use of focus cues for deciding if focus rects are allowed.
/// </summary>
public bool TestForFocusCues { get; set; }
#endregion
#region Values
/// <summary>
/// Gets and sets the source for values.
/// </summary>
public IContentValues Values { get; set; }
#endregion
#region Orientation
/// <summary>
/// Gets and sets the visual orientation.
/// </summary>
public VisualOrientation Orientation
{
[DebuggerStepThrough]
get;
set;
}
#endregion
#region UseMnemonic
/// <summary>
/// Gets and sets the use of mnemonics.
/// </summary>
public bool UseMnemonic
{
[DebuggerStepThrough]
get;
set;
}
#endregion
#region SetPalette
/// <summary>
/// Update the source palette for drawing.
/// </summary>
/// <param name="paletteContent">Palette source for the content.</param>
public void SetPalette(IPaletteContent paletteContent)
{
Debug.Assert(paletteContent != null);
// Use newly provided palette
_paletteContent = paletteContent;
}
#endregion
#region GetPalette
/// <summary>
/// Gets the source palette used for drawing.
/// </summary>
/// <returns>Palette source for the content.</returns>
public IPaletteContent GetPalette()
{
return _paletteContent;
}
#endregion
#region IsImageDisplayed
/// <summary>
/// Get a value indicating if the content image is being displayed.
/// </summary>
/// <param name="context">ViewLayoutContext context.</param>
/// <exception cref="ArgumentNullException"></exception>
public bool IsImageDisplayed(ViewContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
bool isDisplayed = false;
// If we have some content to investigate
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
isDisplayed = context.Renderer.RenderStandardContent.GetContentImageDisplayed(_memento);
}
return isDisplayed;
}
#endregion
#region ImageRectangle
/// <summary>
/// Get a value indicating if the content image is being displayed.
/// </summary>
/// <param name="context">ViewLayoutContext context.</param>
/// <exception cref="ArgumentNullException"></exception>
public Rectangle ImageRectangle(ViewContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Rectangle imageRect = Rectangle.Empty;
// If we have some content to investigate
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
imageRect = context.Renderer.RenderStandardContent.GetContentImageRectangle(_memento);
}
return imageRect;
}
#endregion
#region ShortTextRect
/// <summary>
/// Gets the short text drawing rectangle.
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
/// <returns>Rectangle of short text drawing.</returns>
public Rectangle ShortTextRect(ViewContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Rectangle textRect = Rectangle.Empty;
// If we have some content to investigate
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
textRect = context.Renderer.RenderStandardContent.GetContentShortTextRectangle(_memento);
}
return textRect;
}
#endregion
#region LongTextRect
/// <summary>
/// Gets the short text drawing rectangle.
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
/// <returns>Rectangle of short text drawing.</returns>
public Rectangle LongTextRect(ViewContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Rectangle textRect = Rectangle.Empty;
// If we have some content to investigate
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
textRect = context.Renderer.RenderStandardContent.GetContentLongTextRectangle(_memento);
}
return textRect;
}
#endregion
#region Layout
/// <summary>
/// Discover the preferred size of the element.
/// </summary>
/// <param name="context">Layout context.</param>
/// <exception cref="ArgumentNullException"></exception>
public override Size GetPreferredSize(ViewLayoutContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// By default we take up no space at all
Size preferredSize = Size.Empty;
// If we have some content to encompass
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
// Ask the renderer for the contents preferred size
preferredSize = context.Renderer.RenderStandardContent.GetContentPreferredSize(context,
_paletteContent,
Values,
Orientation,
State,
DrawContentOnComposition,
Glowing);
}
return preferredSize;
}
/// <summary>
/// Perform a layout of the elements.
/// </summary>
/// <param name="context">Layout context.</param>
/// <exception cref="ArgumentNullException"></exception>
public override void Layout(ViewLayoutContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// We take on all the available display area
ClientRectangle = context.DisplayRectangle;
// Do we need to draw the content?
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
// Dispose of old memento first
if (_memento != null)
{
_memento.Dispose();
_memento = null;
}
// Ask the renderer to perform any internal laying out calculations and
// store the returned memento ready for whenever a draw is required
_memento = context.Renderer.RenderStandardContent.LayoutContent(context,
ClientRectangle,
_paletteContent,
Values,
Orientation,
State,
DrawContentOnComposition,
Glowing);
}
}
#endregion
#region Paint
/// <summary>
/// Perform rendering before child elements are rendered.
/// </summary>
/// <param name="context">Rendering context.</param>
public override void RenderBefore(RenderContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Do we need to draw the content?
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
{
bool allowFocusRect = (TestForFocusCues ? ShowFocusCues(context.Control) : true);
// Draw using memento returned from render layout
context.Renderer.RenderStandardContent.DrawContent(context,
ClientRectangle,
_paletteContent,
_memento,
Orientation,
State,
DrawContentOnComposition,
Glowing,
allowFocusRect);
}
}
#endregion
#region Implementation
private bool ShowFocusCues(Control c)
{
if (_pi == null)
{
_pi = typeof(Control).GetProperty("ShowFocusCues", BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.NonPublic);
}
return (bool)_pi.GetValue(c, null);
}
#endregion
}
}
| 35.629545 | 157 | 0.494546 | [
"BSD-3-Clause"
] | Carko/Krypton-Toolkit-Suite-NET-Core | Source/Truncated Namespaces/Source/Krypton Components/Krypton.Toolkit/View Draw/ViewDrawContent.cs | 15,680 | C# |
namespace IIIF.Presentation
{
/// <summary>
/// Contains JSON-LD Contexts for IIIF Presentation API.
/// </summary>
public static class Context
{
/// <summary>
/// JSON-LD context for IIIF presentation 2.
/// </summary>
public const string V2 = "http://iiif.io/api/presentation/2/context.json";
/// <summary>
/// JSON-LD context for IIIF presentation 3.
/// </summary>
public const string V3 = "http://iiif.io/api/presentation/3/context.json";
}
} | 30.833333 | 83 | 0.563964 | [
"MIT"
] | wellcomecollection/iiif-builder | src/Wellcome.Dds/IIIF/Presentation/Context.cs | 557 | C# |
namespace WebApplication.Enums
{
public enum Color
{
Primary,
Info,
Default,
Warning,
Danger
}
} | 13.454545 | 30 | 0.5 | [
"MIT"
] | marcio-eric/adminlte3-netcore | src/WebApplication/Enums/Color.cs | 148 | C# |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
namespace TextAnalysis
{
public partial class frm_main : Form
{
public frm_main()
{
InitializeComponent();
}
private void btn_read_Click(object sender, EventArgs e)
{
//重置标题
lab_title.Text = "字符串分析器";
try
{
//获取剪切板数据
var text = Clipboard.GetText();
var arr = text.ToCharArray();
if (arr.Length == 0)
{
return;
}
//处理一下统计
var count = string.Format("字符串长度：{0}，字节数组长度：{1} ，其中【\\0】字符：{2} 个，【\\r】字符：{3} 个，【\\n】字符：{4} 个", text.Length, arr.Length, Regex.Matches(text, @"\0").Count, Regex.Matches(text, @"\r").Count, Regex.Matches(text, @"\n").Count);
lab_count.Text = count;
//清空原有的字符
pannel_text.Controls.Clear();
foreach (var t in arr)
{
var lb = new LinkLabel();
lb.Text = t.ToString();
lb.BorderStyle = BorderStyle.FixedSingle;
lb.Size = new System.Drawing.Size(30, 30);
lb.Font = new Font("宋体", 12F, FontStyle.Regular, GraphicsUnit.Point, ((byte)(134)));
lb.Margin = new System.Windows.Forms.Padding(0, 0, 5, 10);
lb.Padding = new System.Windows.Forms.Padding(5, 5, 5, 5);
lb.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
lb.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline;
lb.Click += new System.EventHandler(TextClick);
pannel_text.Controls.Add(lb);
}
}
catch (Exception ex)
{
MessageBox.Show("错误，无法获取信息，错误如下：" + ex.ToString());
}
}
//处理点击后的事件
private void TextClick(object sender, EventArgs e)
{
var lab = sender as LinkLabel;
var ts = lab.Text.ToCharArray();
var ascii = (int)ts[0];
var unicode = "\\u" + ((int)ts[0]).ToString("x");
var hint = string.Format("字符：【{0}】，ASCII编码：【{1}】，Unicode编码：【{2}】", lab.Text, ascii, unicode);
//打印
lab_title.Text = hint;
}
}
}
/**
特殊控制字符说明
NUL 空 VT 垂直制表 SYN 空转同步
SOH 标题开始 FF 走纸控制 ETB 信息组传送结束
STX 正文开始 CR 回车 CAN 作废
ETX 正文结束 SO 移位输出 EM 纸尽
EOY 传输结束 SI 移位输入 SUB 换置
ENQ 询问字符 DLE 空格 ESC 换码
ACK 承认 DC1 设备控制1 FS 文字分隔符
BEL 报警 DC2 设备控制2 GS 组分隔符
BS 退一格 DC3 设备控制3 RS 记录分隔符
HT 横向列表 DC4 设备控制4 US 单元分隔符
LF 换行 NAK 否定 DEL 删除
*
**/
| 30.6 | 238 | 0.510836 | [
"Apache-2.0"
] | lxepoo/TextAnalysis | TextAnalysis/frm_main.cs | 3,371 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace Cy.WeChat.Hosting
{
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
}
| 25.888889 | 70 | 0.645207 | [
"MIT"
] | jonny-xhl/Cy.WeChat | Cy.WeChat.Hosting/Program.cs | 699 | C# |
/*
Copyright 2016 Christian Klemm
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
using System;
using System.Globalization;
using System.Windows.Data;
using YTMusicDownloaderLib.Properties;
namespace YTMusicDownloader.Views.Converters
{
internal class PageDisplayConverter : IMultiValueConverter
{
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
var currentPage = values[0].ToString();
var maxPages = values[1].ToString();
if (string.IsNullOrEmpty(currentPage) || string.IsNullOrEmpty(maxPages)) return null;
return $"{currentPage} {Resources.MainWindow_CurrentWorkspace_PageView_PageOf} {maxPages}";
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
throw new NotImplementedException();
}
}
} | 35.195122 | 108 | 0.707554 | [
"Apache-2.0"
] | Victor1890/YTMusicDownloader | src/YTMusicDownloader/Views/Converters/PageDisplayConverter.cs | 1,445 | C# |
using Abp.Domain.Services;
using Cinotam.FileManager.Contracts;
namespace Cinotam.FileManager.Local.LocalFileManager
{
public interface ILocalFileManager : IFileManagerServiceProvider, IDomainService
{
string SaveFileFromBase64String(string base64String, string overrideFormat);
}
}
| 27.727273 | 84 | 0.796721 | [
"MIT"
] | TacoDevs/AbpZero-SPA-only | Cinotam.FileManager.Local/LocalFileManager/ILocalFileManager.cs | 307 | C# |
Subsets and Splits