public Texture2DArray(GraphicsDevice graphicsDevice, int levels, int width, int height, int layers)
: base(graphicsDevice)
{
ThreadingHelper.BlockOnUIThread(() => {
texture = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2DArray, texture);
GL.TexStorage3D(TextureTarget3d.Texture2DArray, levels, SizedInternalFormat.Rgba8, width, height, Math.Max(layers, 1));
});
Width = width;
Height = height;
LayerCount = layers;
}
internal void Compile()
{
ThreadingHelper.BlockOnUIThread(() => {
GL.CompileShader(shader);
int compiled;
GL.GetShader(shader, ShaderParameter.CompileStatus, out compiled);
if (compiled != 1)
{
string error = GL.GetShaderInfoLog(shader);
throw new Exception(error);
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="LogManager"/>.
/// </summary>
public LogManager()
{
ConfigManager.TryRegisterService(this);
Sources = new LogSourceList(this)
{
Application,
new UnhandledExceptionSource()
};
_flushTimer = ThreadingHelper.Timer(Flush);
FlushInterval = TimeSpan.FromMilliseconds(500);
}
public void SetData <T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
{
ThreadingHelper.BlockOnUIThread(() =>
{
//vao.Bind();//TODO: verify
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GCHandle buffer = GCHandle.Alloc(data, GCHandleType.Pinned);
GL.BufferSubData(BufferTarget.ArrayBuffer, new IntPtr(offsetInBytes), new IntPtr(elementCount * vertexStride), buffer.AddrOfPinnedObject() + startIndex * vertexStride);
buffer.Free();
});
GraphicsDevice.CheckError();
}
/// <summary>
/// To subscribe for news.
/// </summary>
public void SubscribeNews()
{
_newsTimer = ThreadingHelper.Timer(() =>
{
try
{
RequestNews();
}
catch (Exception ex)
{
ex.LogError();
}
}).Interval(TimeSpan.Zero, TimeSpan.FromDays(1));
}
private void PreprocessMipMaps()
{
bool hwCompressed = Format == TextureContentFormat.DXT1 || Format == TextureContentFormat.DXT3 || Format == TextureContentFormat.DXT5;
int width = Width, height = Height;
int realCount = 0;
for (int i = 0; i < (GenerateMipMaps ? 1 : MipMapCount); i++)
{
if (hwCompressed)
{
int dataSize = 0;
byte[] data = null;
ThreadingHelper.BlockOnUIThread(() =>
{
GL.BindTexture(TextureTarget.Texture2D, texture);
GL.GetTexLevelParameter(TextureTarget.Texture2D, i, GetTextureParameter.TextureCompressedImageSize, out dataSize);
data = new byte[dataSize];
GL.GetCompressedTexImage(TextureTarget.Texture2D, i, data);
});
MipMaps.Add(new TextureContentMipMap(width, height, Format, data));
}
else
{
var bmp = new System.Drawing.Bitmap(width, height);
var bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, width, height), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
ThreadingHelper.BlockOnUIThread(() =>
{
GL.BindTexture(TextureTarget.Texture2D, texture);
GL.GetTexImage(TextureTarget.Texture2D, i, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0);
});
bmp.UnlockBits(bmpData);
MipMaps.Add(new TextureContentMipMap(width, height, Format, bmp));
}
width /= 2;
height /= 2;
realCount++;
if (width == 0 || height == 0)
{
break;
}
}
if (!GenerateMipMaps)
{
MipMapCount = realCount;
}
}
private void BrowsePath(object obj)
{
FolderBrowserWindow window = new FolderBrowserWindow();
if (this.viewModel == null)
{
this.viewModel = new FolderBrowserViewModel(this.AdapterBase)
{
Message = "Select the destination folder"
};
if (!string.IsNullOrWhiteSpace(this.DestinationPath))
{
//this.viewModel.SelectedPath = this.DestinationPath;
}
}
if (!this.viewModel.RootFolders.Any())
{
this.viewModel.LoadRootFolders();
}
window.DataContext = this.viewModel;
if (!string.IsNullOrWhiteSpace(this.DestinationPath))
{
ThreadingHelper.StartBackgroundTask(
(s, t) =>
{
foreach (FolderViewModel root in this.viewModel.RootFolders)
{
FolderViewModel folder = this.GetFolderByPath(root,
this.DestinationPath.Split(new[] { this.AdapterBase.PathSeparator },
StringSplitOptions.None).ToList());
if (folder != null)
{
folder.IsExpanded = true;
folder.IsSelected = true;
break;
}
}
});
}
bool?dialogResult = window.ShowDialog();
if (dialogResult == true && this.viewModel.SelectedFolder != null)
{
this.DestinationPath = this.viewModel.SelectedFolder.GetPath();
}
}
private bool WaitExtracted(int millisecondsTimeout, CancellationToken cancellationToken)
{
var spinWait = new SpinWait();
var spinCount = _spinCount;
if (IsSet)
{
return(true);
}
var start = ThreadingHelper.TicksNow();
retry_longTimeout:
if (IsSet)
{
return(true);
}
cancellationToken.ThrowIfCancellationRequested();
GC.KeepAlive(cancellationToken.WaitHandle);
var elapsed = ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start);
if (elapsed < millisecondsTimeout)
{
if (spinCount > 0)
{
spinCount--;
spinWait.SpinOnce();
goto retry_longTimeout;
}
var handle = RetriveWaitHandle();
var remaining = millisecondsTimeout - (int)elapsed;
if (remaining > 0)
{
var result = WaitHandle.WaitAny
(
new[]
{
handle,
cancellationToken.WaitHandle
},
remaining
);
cancellationToken.ThrowIfCancellationRequested();
GC.KeepAlive(cancellationToken.WaitHandle);
return(result != WaitHandle.WaitTimeout);
}
}
cancellationToken.ThrowIfCancellationRequested();
GC.KeepAlive(cancellationToken.WaitHandle);
return(false);
}
async Task Initialize()
{
// The services needed by the usage tracker are loaded when they are first needed to
// improve the startup time of the extension.
if (!initialized)
{
await ThreadingHelper.SwitchToMainThreadAsync();
client = gitHubServiceProvider.TryGetService <IMetricsService>();
connectionManager = gitHubServiceProvider.GetService <IConnectionManager>();
vsservices = gitHubServiceProvider.GetService <IVSServices>();
initialized = true;
}
}
protected override async Task InitializeAsync(
CancellationToken cancellationToken,
IProgress <ServiceProgressData> progress)
{
var menuService = (IMenuCommandService)(await GetServiceAsync(typeof(IMenuCommandService)));
var componentModel = (IComponentModel)(await GetServiceAsync(typeof(SComponentModel)));
var exports = componentModel.DefaultExportProvider;
await ThreadingHelper.SwitchToMainThreadAsync();
menuService.AddCommands(
exports.GetExportedValue <INextInlineCommentCommand>(),
exports.GetExportedValue <IPreviousInlineCommentCommand>());
}
private void TryCreateTimer()
{
lock (_syncRoot)
{
if (_isFlushing || _flushTimer != null)
{
return;
}
_flushTimer = ThreadingHelper
.Timer(() => CultureInfo.InvariantCulture.DoInCulture(OnFlush))
.Interval(_flushInterval);
}
}
async Task Initialize()
{
if (storePath == null)
{
await ThreadingHelper.SwitchToMainThreadAsync();
var program = serviceProvider.GetService <IProgram>();
var localApplicationDataPath = environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
storePath = Path.Combine(localApplicationDataPath, program.ApplicationName, StoreFileName);
userStorePath = Path.Combine(localApplicationDataPath, program.ApplicationName, UserStoreFileName);
}
}
private bool WaitExtracted(int millisecondsTimeout)
{
var count = 0;
if (IsSet)
{
return(true);
}
var start = ThreadingHelper.TicksNow();
if (millisecondsTimeout > INT_LongTimeOutHint)
{
retry_longTimeout:
if (IsSet)
{
return(true);
}
var elapsed = ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start);
if (elapsed < millisecondsTimeout)
{
if (elapsed < INT_LongTimeOutHint)
{
ThreadingHelper.SpinOnce(ref count);
goto retry_longTimeout;
}
var handle = RetriveWaitHandle();
var remaining = millisecondsTimeout - (int)elapsed;
if (remaining > 0)
{
return(handle.WaitOne(remaining));
}
}
}
else
{
retry_shortTimeout:
if (IsSet)
{
return(true);
}
var elapsed = ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start);
if (elapsed < millisecondsTimeout)
{
ThreadingHelper.SpinOnce(ref count);
goto retry_shortTimeout;
}
}
return(false);
}
/// <summary>
/// To start timer of getting from sent <paramref name="connector" /> of real time candles.
/// </summary>
/// <typeparam name="TConnector">The type of the connection implementing <see cref="IExternalCandleSource"/>.</typeparam>
/// <param name="connector">The connection implementing <see cref="IExternalCandleSource"/>.</param>
/// <param name="registeredSeries">All registered candles series.</param>
/// <param name="offset">The time shift for the new request to obtain a new candle. It is needed for the server will have time to create data in its candles storage.</param>
/// <param name="requestNewCandles">The handler getting new candles.</param>
/// <param name="interval">The interval between data updates.</param>
/// <returns>Created timer.</returns>
public static Timer StartRealTime <TConnector>(this TConnector connector, CachedSynchronizedSet <CandleSeries> registeredSeries, TimeSpan offset, Action <CandleSeries, Range <DateTimeOffset> > requestNewCandles, TimeSpan interval)
where TConnector : class, IConnector, IExternalCandleSource
{
if (connector == null)
{
throw new ArgumentNullException(nameof(connector));
}
if (registeredSeries == null)
{
throw new ArgumentNullException(nameof(registeredSeries));
}
if (requestNewCandles == null)
{
throw new ArgumentNullException(nameof(requestNewCandles));
}
return(ThreadingHelper.Timer(() =>
{
try
{
if (connector.ConnectionState != ConnectionStates.Connected)
{
return;
}
lock (registeredSeries.SyncRoot)
{
foreach (var series in registeredSeries.Cache)
{
var tf = (TimeSpan)series.Arg;
var time = connector.CurrentTime;
var bounds = tf.GetCandleBounds(time, series.Security.Board);
var beginTime = (time - bounds.Min) < offset ? (bounds.Min - tf) : bounds.Min;
var finishTime = bounds.Max;
requestNewCandles(series, new Range <DateTimeOffset>(beginTime, finishTime));
}
}
}
catch (Exception ex)
{
ex.LogError();
}
})
.Interval(interval));
}
async Task RepoChanged(ILocalRepositoryModel repository)
{
try
{
await ThreadingHelper.SwitchToMainThreadAsync();
await EnsureLoggedIn(repository);
if (repository != this.repository)
{
this.repository = repository;
CurrentSession = null;
sessions.Clear();
}
var modelService = hosts.LookupHost(HostAddress.Create(repository.CloneUrl))?.ModelService;
var session = CurrentSession;
if (modelService != null)
{
var pr = await service.GetPullRequestForCurrentBranch(repository).FirstOrDefaultAsync();
if (pr?.Item1 != (CurrentSession?.PullRequest.Base.RepositoryCloneUrl.Owner) &&
pr?.Item2 != (CurrentSession?.PullRequest.Number))
{
var pullRequest = await GetPullRequestForTip(modelService, repository);
if (pullRequest != null)
{
var newSession = await GetSessionInternal(pullRequest);;
if (newSession != null)
{
newSession.IsCheckedOut = true;
}
session = newSession;
}
}
}
else
{
session = null;
}
CurrentSession = session;
}
catch
{
// TODO: Log
}
}
private void WaitAntecedent(CancellationToken cancellationToken, int milliseconds, long start)
{
if (IsContinuationTask)
{
var antecedent = ((IContinuationTask)this).Antecedent;
if (antecedent != null)
{
antecedent.Wait
(
milliseconds - (int)ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start),
cancellationToken
);
}
}
}
private void WaitAntecedent(CancellationToken cancellationToken, int milliseconds, long start)
{
if (!IsContinuationTask)
{
return;
}
var antecedent = ((IContinuationTask)this).Antecedent;
antecedent?.Wait
(
milliseconds - (int)ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start),
cancellationToken
);
}
private ManualResetEvent TryGetWaitHandleExtracted()
{
var handle = ThreadingHelper.VolatileRead(ref _handle);
if (handle != null)
{
if (Thread.VolatileRead(ref _requested) == 2)
{
return(handle);
}
handle.Close();
}
Thread.VolatileWrite(ref _requested, -1);
throw new ObjectDisposedException(GetType().FullName);
}
/// <summary>
/// Initializes a new instance of the <see cref="CachedBasketMarketDataStorage{T}"/>.
/// </summary>
public CachedBasketMarketDataStorage(BasketMarketDataStorage <T> basketStorage)
{
if (basketStorage == null)
{
throw new ArgumentNullException(nameof(basketStorage));
}
_basketStorage = basketStorage;
_cancellationToken = new CancellationTokenSource();
ThreadingHelper
.Thread(() => CultureInfo.InvariantCulture.DoInCulture(OnLoad))
.Name("Cached marketdata storage thread.")
.Launch();
}
/// <summary>
/// Добавить сообщение в очередь на отправку.
/// </summary>
/// <param name="message">Сообщение.</param>
private void EnqueueMessage(LogMessage message)
{
if (message.IsDispose)
{
_queue.Close();
return;
}
_queue.Enqueue(Tuple.Create(GetSubject(message), message.Message));
lock (_queue.SyncRoot)
{
if (_isThreadStarted)
{
return;
}
_isThreadStarted = true;
ThreadingHelper.Thread(() =>
{
try
{
using (var email = CreateClient())
{
while (true)
{
Tuple <string, string> m;
if (!_queue.TryDequeue(out m))
{
break;
}
email.Send(From, To, m.Item1, m.Item2);
}
}
lock (_queue.SyncRoot)
_isThreadStarted = false;
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
}).Name("Email log queue").Launch();
}
}
private void LookupPanel_OnLookup(Security filter)
{
SecuritiesAll.SecurityFilter = filter.Code;
var downloader = Task as ISecurityDownloader;
if (downloader == null)
{
return;
}
BusyIndicator.BusyContent = LocalizedStrings.Str2834;
BusyIndicator.IsBusy = true;
ThreadingHelper
.Thread(() =>
{
var securities = ConfigManager.GetService <IEntityRegistry>().Securities;
try
{
downloader.Refresh(securities, filter, s => { }, () => _isClosed);
}
catch (Exception ex)
{
ex.LogError();
}
try
{
securities.DelayAction.WaitFlush();
}
catch (Exception ex)
{
ex.LogError();
}
try
{
this.GuiAsync(() => BusyIndicator.IsBusy = false);
}
catch (Exception ex)
{
ex.LogError();
}
})
.Launch();
}
async Task InitializeMenus()
{
var menus = await GetServiceAsync(typeof(IMenuProvider)) as IMenuProvider;
await ThreadingHelper.SwitchToMainThreadAsync();
foreach (var menu in menus.Menus)
{
serviceProvider.AddCommandHandler(menu.Guid, menu.CmdId, (s, e) => menu.Activate());
}
foreach (var menu in menus.DynamicMenus)
{
serviceProvider.AddCommandHandler(menu.Guid, menu.CmdId, menu.CanShow, () => menu.Activate());
}
}
public async Task <TwoFactorChallengeResult> HandleTwoFactorException(TwoFactorAuthorizationException exception)
{
await ThreadingHelper.SwitchToMainThreadAsync();
var userError = new TwoFactorRequiredUserError(exception);
var result = await twoFactorDialog.Show(userError);
if (result != null)
{
return(result);
}
else
{
throw exception;
}
}
internal void FinishThreadAbortedTask(bool exceptionAdded, bool delegateRan)
{
if (Interlocked.CompareExchange(ref _threadAbortedmanaged, 1, 0) == 0)
{
var exceptionsHolder = ThreadingHelper.VolatileRead(ref _exceptionsHolder);
if (exceptionsHolder == null)
{
return;
}
if (exceptionAdded)
{
exceptionsHolder.MarkAsHandled(false);
}
Finish(delegateRan);
}
}
public int Release(int releaseCount)
{
CheckDisposed();
if (releaseCount < 1)
{
throw new ArgumentOutOfRangeException("releaseCount", "releaseCount is less than 1");
}
int oldValue;
if (ThreadingHelper.SpinWaitRelativeExchangeUnlessNegative(ref _count, -releaseCount, out oldValue))
{
Awake();
return(oldValue);
}
throw new SemaphoreFullException();
}
public IndexBuffer(GraphicsDevice graphicsDevice, DrawElementsType indexElementSize, int indexCount, BufferUsageHint usage = BufferUsageHint.StaticDraw)
: base(graphicsDevice)
{
this.IndexElementSize = indexElementSize;
this.IndexCount = indexCount;
this.BufferUsage = usage;
ThreadingHelper.BlockOnUIThread(() =>
{
ibo = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo);
elementSize = (indexElementSize == DrawElementsType.UnsignedByte ? 1 : (indexElementSize == DrawElementsType.UnsignedShort ? 2 : 4));
GL.BufferData(BufferTarget.ElementArrayBuffer, new IntPtr(indexCount * elementSize), IntPtr.Zero, (OpenTK.Graphics.OpenGL4.BufferUsageHint)BufferUsage);
});
GraphicsDevice.CheckError();
//buffer = new byte[indexCount * (int)IndexElementSize / 8];
}
public void TryEnter(int millisecondsTimeout, ref bool lockTaken)
{
if (_disableThreadTracking)
{
lockTaken |= ThreadingHelper.SpinWaitSet(ref _isHeld, 1, 0, millisecondsTimeout);
}
else
{
if (IsHeldByCurrentThread)
{
//Throw on recursion
throw new LockRecursionException();
}
lockTaken |= (ThreadingHelper.SpinWaitSet(ref _isHeld, 1, 0, millisecondsTimeout) && ReferenceEquals(Interlocked.CompareExchange(ref _ownerThread, Thread.CurrentThread, null), null));
}
}
public override void Wait(int milliseconds, CancellationToken cancellationToken)
{
if (Interlocked.CompareExchange(ref _status, 1, 0) != 0)
{
base.Wait(milliseconds, cancellationToken);
}
else
{
var start = ThreadingHelper.TicksNow();
base.Execute();
milliseconds = milliseconds - (int)ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start);
if (milliseconds > 0)
{
base.Wait(milliseconds, cancellationToken);
}
}
}
public void SetData <T>(T[] data) where T : struct
{
if (data.Length == 0)
{
return;
}
ThreadingHelper.BlockOnUIThread(() =>
{
Bind();
GL.BufferSubData <T>(BufferTarget.ElementArrayBuffer, IntPtr.Zero, new IntPtr(data.Length * Marshal.SizeOf(default(T))), data); //TODO:
});
GraphicsDevice.CheckError();
//Buffer.BlockCopy (data, 0, buffer, 0, data.Length);
}
public override void Wait(int milliseconds)
{
if (Interlocked.CompareExchange(ref _status, 1, 0) != 0)
{
base.Wait(milliseconds);
}
else
{
var start = ThreadingHelper.TicksNow();
base.Initialize();
milliseconds -= (int)ThreadingHelper.Milliseconds(ThreadingHelper.TicksNow() - start);
if (milliseconds > 0)
{
base.Wait(milliseconds);
}
}
}
