/// <summary>
/// Performs the <see cref="Closing"/> operator on the given
/// <see cref="Matrix"/>.
/// </summary>
/// <param name="src">
/// The <see cref="Matrix"/> which should be used by the
/// operator.
/// </param>
/// <returns> The closed <see cref="Matrix"/>. </returns>
public Matrix Execute (Matrix src)
{
Closing closing = new Closing (this.se);
Matrix closed = closing.Execute (src);
return (src.isLogical() ?
(closed & (!src)) : (closed - src));
}
/// <summary>
/// Fires the Closing event.
/// </summary>
/// <param name="cea">An CancelEventArgs containing the event data.</param>
public void OnClosing(CancelEventArgs cea)
{
if (_parent != null)
{
_parent.OnClosing(cea);
}
else
{
Closing?.Invoke(this, cea);
}
}
public StateBankAccount()
{
_confirmingIdentity = new ConfirmingIdentity(this);
_accountActive = new AccountActive(this);
_frozen = new Frozen(this);
_closing = new Closing(this);
_closed = new Closed(this);
Balance = 0.0;
_state = _confirmingIdentity;
}
protected override void OnDocumentClosing(IDocument document)
{
var sd = document as ISledDocument;
if (sd == null)
{
return;
}
Closing.Raise(this, new SledDocumentServiceEventArgs(sd));
}
private void closingзакрытиеToolStripMenuItem_Click(object sender, EventArgs e)
{
if (mmCore.coreSize == 0)
{
MessageBox.Show("Set core first", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
Filters filter = new Closing(mmCore);
backgroundWorker1.RunWorkerAsync(filter);
}
private void OnClosing()
{
var e = new CancellableEventArgs();
Closing?.Invoke(this, e);
if (!e.Cancelled)
{
_nativeWindow.Destroy();
CoreWindow cw;
_coreWindows.TryRemove(_nativeWindow, out cw);
}
}
public void Close()
{
if (Closing != null)
{
Closing.Invoke(this, new EventArgs() as MouseEventArgs);
}
if (_timerOpen != null)
{
_timerOpen.Stop();
}
MenuPopup.IsOpen = false;
OpenMenuList.Remove(this);
}
private void закрытиеToolStripMenuItem_Click(object sender, EventArgs e)
{
if (kernel != null)
{
Closing filter = new Closing(kernel);
backgroundWorker1.RunWorkerAsync(filter);
}
else
{
Closing filter = new Closing();
backgroundWorker1.RunWorkerAsync(filter);
}
}
/// <summary>
/// Raises the Closing event with a deferral to wait the event handlers to complete the execution.
/// </summary>
/// <returns></returns>
protected virtual Task OnClosingAsync()
{
if (!_closingInvoked)
{
_closingInvoked = true;
var e = new DeferralEventArgs();
Closing.RaiseEvent(this, e);
return(e.WaitForDeferralsAsync());
}
return(Task.FromResult <object>(null));
}
public string PrintError(Closing obj)
{
string erroroutput = "";
KeyValuePair <string, string> first = obj.Errors.ElementAt(0);
erroroutput += first.Key + "," + first.Value;
foreach (KeyValuePair <string, string> pair in obj.Errors.Skip(1))
{
erroroutput += Environment.NewLine;
erroroutput += pair.Key + "," + pair.Value;
}
return(erroroutput);
}
/// <summary>
/// Dismiss the notification
/// </summary>
/// <param name="dismissKind">Kind of action that triggered dismiss event</param>
private void Dismiss(InAppNotificationDismissKind dismissKind)
{
lock (_openAnimationTimer)
lock (_closingAnimationTimer)
lock (_dismissTimer)
{
if (Visibility == Visibility.Visible)
{
_dismissTimer.Stop();
// Continue to display notification if on remaining stacked notification
if (_stackedNotificationOptions.Any())
{
_stackedNotificationOptions.RemoveAt(0);
if (_stackedNotificationOptions.Any())
{
var notificationOptions = _stackedNotificationOptions[0];
UpdateContent(notificationOptions);
if (notificationOptions.Duration > 0)
{
_dismissTimer.Interval = TimeSpan.FromMilliseconds(notificationOptions.Duration);
_dismissTimer.Start();
}
return;
}
}
_openAnimationTimer.Stop();
_closingAnimationTimer.Stop();
var closingEventArgs = new InAppNotificationClosingEventArgs(dismissKind);
Closing?.Invoke(this, closingEventArgs);
if (closingEventArgs.Cancel)
{
return;
}
VisualStateManager.GoToState(this, StateContentCollapsed, true);
_lastDismissKind = dismissKind;
_closingAnimationTimer.Interval = AnimationDuration;
_closingAnimationTimer.Start();
}
}
}
private void OnIsOpenChanged()
{
IsOpenChanged?.Invoke(this, EventArgs.Empty);
if (!IsOpen)
{
if (PopupAnimation == PopupAnimation.Fade && SuppressFadeAnimation)
{
StopAnimation();
}
Closing?.Invoke(this, EventArgs.Empty);
}
}
public Closing CloseObject(Closing closing, IAccountService _accountService,
IGeneralLedgerJournalService _generalLedgerJournalService, IValidCombService _validCombService)
{
if (_validator.ValidCloseObject(closing, this))
{
// Count ValidComb for each leaf account
IList <Account> leafAccounts = _accountService.GetLeafObjects();
foreach (var leaf in leafAccounts)
{
DateTime EndDate = closing.EndDatePeriod.AddDays(1);
IList <GeneralLedgerJournal> ledgers = _generalLedgerJournalService.GetQueryable()
.Where(x => x.AccountId == leaf.Id &&
x.TransactionDate >= closing.BeginningPeriod &&
x.TransactionDate < EndDate)
.ToList();
decimal totalAmountInLedgers = 0;
foreach (var ledger in ledgers)
{
Account account = _accountService.GetObjectById(ledger.AccountId);
if ((ledger.Status == Constant.GeneralLedgerStatus.Debit &&
(account.Group == Constant.AccountGroup.Asset ||
account.Group == Constant.AccountGroup.Expense)) ||
(ledger.Status == Constant.GeneralLedgerStatus.Credit &&
(account.Group == Constant.AccountGroup.Liability ||
account.Group == Constant.AccountGroup.Equity ||
account.Group == Constant.AccountGroup.Revenue)))
{
totalAmountInLedgers += ledger.Amount;
}
else
{
totalAmountInLedgers -= ledger.Amount;
}
}
ValidComb validComb = _validCombService.FindOrCreateObjectByAccountAndClosing(leaf.Id, closing.Id);
validComb.Amount = totalAmountInLedgers;
_validCombService.UpdateObject(validComb, _accountService, this);
}
var groupNodeAccounts = _accountService.GetQueryable().Where(x => !x.IsLeaf).OrderByDescending(x => x.Level);
foreach (var groupNode in groupNodeAccounts)
{
FillValidComb(groupNode, closing, _accountService, _validCombService);
}
_repository.CloseObject(closing);
}
return(closing);
}
private void fillHoleToolStripMenuItem_Click(object sender, EventArgs e)
{
GrayscaleBT709 greyscale = new GrayscaleBT709();
Bitmap grey = greyscale.Apply(skin);
Threshold filter = new Threshold(100);
filter.ApplyInPlace(grey);
Closing close = new Closing();
Bitmap j = close.Apply(grey);
Opening open = new Opening();
k = open.Apply(j);
pictureBox3.Image = k;
}
public async Task <ClosingResult> SaveAsync(string sessionKey, Closing closing)
{
return(await authorizationProcessor.DoAuthorizeAsync(sessionKey, async token =>
{
var result = await closingProcessor.SaveAsync(closing, token);
return new ClosingResult
{
ProcessResult = new ProcessResult {
Result = true
},
Closing = result,
};
}, logger));
}
public virtual void Shutdown()
{
Closing?.Invoke();
// ProjectSettings is accessing some information from runtime during save
AndroidLogcatProjectSettings.Save(m_ProjectSettings, ProjectSettingsPath, this);
SaveEditorSettings(m_Settings);
m_Initialized = false;
m_Settings = null;
m_ProjectSettings = null;
m_Tools = null;
m_Dispatcher.Shutdown();
m_Dispatcher = null;
}
/// <summary>
/// Closes all cells.
/// </summary>
public void Close()
{
Closing?.Invoke(this, EventArgs.Empty);
// rotate plus icon
CATransaction.AnimationDuration = 0.8;
plusLayer.Transform = CATransform3D.MakeRotation(0, 0, 0, 1);
baseView.Close(CellArray());
IsClosed = true;
Closed?.Invoke(this, EventArgs.Empty);
}
internal void Close()
{
var args = new CancelEventArgs(false);
Closing?.Invoke(this, args);
if (args.Cancel)
{
return;
}
Terminal.Gui.Application.RequestStop();
Terminal.Gui.Application.Refresh();
Closed?.Invoke(this, EventArgs.Empty);
}
public Closing OpenObject(Closing closing, IAccountService _accountService, IValidCombService _validCombService)
{
if (_validator.ValidOpenObject(closing))
{
IList <Account> allAccounts = _accountService.GetAll();
foreach (var account in allAccounts)
{
ValidComb validComb = _validCombService.FindOrCreateObjectByAccountAndClosing(account.Id, closing.Id);
validComb.Amount = 0;
_validCombService.UpdateObject(validComb, _accountService, this);
}
}
return(_repository.OpenObject(closing));
}
internal void Close()
{
var args = new EventArgs();
try
{
Closing?.Invoke(this, args);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
CloseComplete?.Invoke(this, args);
}
internal void ProcessClose(bool updateActiveContext)
{
// Todo: it might already be closed...
// For now, continue asserting as it can be clicked through.
Debug.Assert(_openTextBuffer != null);
Closing?.Invoke(this, updateActiveContext);
var buffer = _openTextBuffer;
_openTextBuffer = null;
_snapshotTracker.StopTracking(buffer);
_fileChangeTracker.StartFileChangeListeningAsync();
}
/// <summary>
/// Gets the window.
/// </summary>
/// <param name="viewModel">The view model.</param>
/// <param name="isDialogWindow">if set to <c>true</c> [is dialog window].</param>
/// <returns>Window.</returns>
private Window GetWindow(ViewModelBase viewModel, bool isDialogWindow)
{
lock (LockObject)
{
var window = _openedWindows.SingleOrDefault(w => w.DataContext == viewModel);
if (window != null)
{
window.WindowState = WindowState.Normal;
window.Activate();
return(window);
}
if (isDialogWindow)
{
// Set window owner in order to prevent that it becomes hidden when minimizing the application
window = new DialogWindow
{
Owner = _openedWindows.Any() ? _openedWindows.Last() : Application.Current.MainWindow
};
}
else
{
// Doesn't need a window owner since it's shown in the taskbar
window = new StandardWindow();
}
_openedWindows.Add(window);
window.Closed += (sender, e) =>
{
Closed?.Invoke(sender, e);
_openedWindows.Remove(window);
window = null;
if (!_openedWindows.Any() && Application.Current.MainWindow != null)
{
Application.Current.MainWindow.Activate();
}
};
window.Closing += (sender, e) =>
{
Closing?.Invoke(sender, e);
};
return(window);
}
}
private bool InternalHide(LightContentDialogResult contentDialogResult)
{
LightContentDialogClosingEventArgs lightContentDialogClosingEventArgs = new LightContentDialogClosingEventArgs(contentDialogResult);
Closing?.Invoke(this, lightContentDialogClosingEventArgs);
if (!lightContentDialogClosingEventArgs.Cancel && (global::Avalonia.Application.Current.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)?.MainWindow is FormsWindow window)
{
window.Hide();
LightContentDialogClosedEventArgs lightContentDialogClosedEventArgs = new LightContentDialogClosedEventArgs(contentDialogResult);
Closed?.Invoke(this, lightContentDialogClosedEventArgs);
return(true);
}
return(false);
}
/// <inheritdoc />
public void Close(string reason)
{
Closing?.Invoke(this, new ConnectionClosingEventArgs(reason));
Closing = null;
if (!_isActive.FlipIf(true))
{
return;
}
_socket.Close();
_receiveDescriptor.Close();
_sendDescriptor.Close();
}
protected virtual async Task OnClosing(WorkbenchWindowEventArgs e)
{
if (Closing != null)
{
foreach (var handler in Closing.GetInvocationList().Cast <WorkbenchWindowAsyncEventHandler> ())
{
await handler(this, e);
if (e.Cancel)
{
break;
}
}
}
}
async Task InternalCloseAsync(TimeSpan timeout)
{
State = CommunicationState.Closing;
if (Closing != null)
{
Closing.Invoke(this, EventArgs.Empty);
}
await CloseAsync(timeout);
State = CommunicationState.Closed;
if (Closed != null)
{
Closed.Invoke(this, EventArgs.Empty);
}
}
private bool InternalHide(LightContentDialogResult contentDialogResult)
{
LightContentDialogClosingEventArgs lightContentDialogClosingEventArgs = new LightContentDialogClosingEventArgs(contentDialogResult);
Closing?.Invoke(this, lightContentDialogClosingEventArgs);
if (!lightContentDialogClosingEventArgs.Cancel && System.Windows.Application.Current.MainWindow is FormsWindow window)
{
window.HideContentDialog();
LightContentDialogClosedEventArgs lightContentDialogClosedEventArgs = new LightContentDialogClosedEventArgs(contentDialogResult);
Closed?.Invoke(this, lightContentDialogClosedEventArgs);
return(true);
}
return(false);
}
private bool OnIsCoerceValue(bool baseValue)
{
var ev = new CancelEventArgs(false);
if (baseValue)
{
Opening?.Invoke(this, ev);
return(!ev.Cancel);
}
else
{
Closing?.Invoke(this, ev);
return(ev.Cancel);
}
} // proc OnIsCoerceValue
async Task OnClosing(DocumentCloseEventArgs e)
{
if (Closing != null)
{
foreach (var handler in Closing.GetInvocationList().Cast <DocumentCloseAsyncEventHandler> ())
{
await handler(this, e);
if (e.Cancel)
{
break;
}
}
}
}
public ActionResult ReportBalanceSheet(Nullable <int> closingId)
{
var company = _companyService.GetQueryable().FirstOrDefault();
Closing closing = _closingService.GetObjectById(closingId.GetValueOrDefault());
if (closing == null)
{
return(Content(Constant.ErrorPage.ClosingNotFound));
}
var balanceValidComb = _validCombService.GetQueryable().Include("Account").Include("Closing")
.Where(x => x.ClosingId == closing.Id & x.Account.Level == 2);
List <ModelBalanceSheet> query = new List <ModelBalanceSheet>();
query = (from obj in balanceValidComb
select new ModelBalanceSheet()
{
CompanyName = company.Name,
StartDate = closing.BeginningPeriod,
EndDate = closing.EndDatePeriod,
DCNote = (obj.Account.Group == Constant.AccountGroup.Asset ||
obj.Account.Group == Constant.AccountGroup.Expense) ? "D" : "C",
AccountName = obj.Account.Code.Substring(0, 1),
AccountGroup = (obj.Account.Group == Constant.AccountGroup.Asset) ? "Asset" :
(obj.Account.Group == Constant.AccountGroup.Expense) ? "Expense" :
(obj.Account.Group == Constant.AccountGroup.Liability) ? "Liability" :
(obj.Account.Group == Constant.AccountGroup.Equity) ? "Equity" :
(obj.Account.Group == Constant.AccountGroup.Revenue) ? "Revenue" : "",
AccountTitle = obj.Account.Name,
CurrentAmount = obj.Amount,
PrevAmount = obj.Amount,
ASSET = "nonASSET", // untuk Fix Asset ? "ASSET" : "nonASSET",
AccountCode = obj.Account.Code
}).OrderBy(x => x.AccountCode).ToList();
var rd = new ReportDocument();
//Loading Report
rd.Load(Server.MapPath("~/") + "Reports/Finance/BalanceSheet.rpt");
// Setting report data source
rd.SetDataSource(query);
var stream = rd.ExportToStream(CrystalDecisions.Shared.ExportFormatType.PortableDocFormat);
return(File(stream, "application/pdf"));
}
public static Bitmap ProcessImage(string imagePath)
{
var img = AForge.Imaging.Image.FromFile(imagePath);
ContrastStretch filterContrastStretch = new ContrastStretch();
filterContrastStretch.ApplyInPlace(img);
try
{
img = Grayscale.CommonAlgorithms.BT709.Apply(img);
}
catch
{
System.Windows.Forms.MessageBox.Show("The image should not be grayscale");
}
Opening filterOpening = new Opening();
filterOpening.ApplyInPlace(img);
SobelEdgeDetector sobel = new SobelEdgeDetector();
sobel.ApplyInPlace(img);
Closing filterClosing = new Closing();
filterClosing.ApplyInPlace(img);
Threshold threshold = new Threshold(100);
threshold.ApplyInPlace(img);
FillHoles fillHoles = new FillHoles();
fillHoles.MaxHoleWidth = img.Width;
fillHoles.MaxHoleHeight = img.Height;
fillHoles.CoupledSizeFiltering = false;
fillHoles.ApplyInPlace(img);
filterOpening.ApplyInPlace(img);
Erosion filterErosion = new Erosion();
filterErosion.ApplyInPlace(img);
return(img);
}
public void OnClose(int Reason)
{
int IndentSize;
IndentSize = Debug.IndentSize;
Debug.WriteLine(IndentSize);
CloseReason = (swPropertyManagerPageCloseReasons_e)Reason;
var arg = new ClosingArg();
Closing?.Invoke(CloseReason, arg);
if (arg.Cancel)
{
if (!string.IsNullOrEmpty(arg.ErrorTitle) || !string.IsNullOrEmpty(arg.ErrorMessage))
{
var title = !string.IsNullOrEmpty(arg.ErrorTitle) ? arg.ErrorTitle : "Error";
ShowBubbleTooltipAt2(title, arg.ErrorMessage);
}
throw new COMException(arg.ErrorMessage, S_FALSE);
}
//执行Command接口
if (CloseReason == swPropertyManagerPageCloseReasons_e.swPropertyManagerPageClose_Okay)
{
bool canExecute = CloseCommand == null ? true : CloseCommand.CanExecute(null);
if (!canExecute)
{
if (CloseCommand is CloseCommand clsCmd)
{
ShowBubbleTooltipAt2(clsCmd.ErrorTitle, clsCmd.BubbleTooltip);
}
else
{
ShowBubbleTooltipAt2("无法执行", "未知错误");
}
const int S_FALSE = 1;
throw new COMException(arg.ErrorMessage, S_FALSE);
}
}
//DeAttach Doc Selection Event
//_selectionBoxs.Clear();
//DeAttachDocEvent();
}
