internal TransferErrorDialogResult ShowCorrespondingErrorDialog(Exception exception, bool feedbackNeeded = true)
        {
            var transferException = exception as TransferException;
            var exceptionType     = transferException != null ? transferException.Type : TransferErrorType.NotSpecified;

            _elapsedTimeMeter.Stop();

            var result = new TransferErrorDialogResult(ErrorResolutionBehavior.Cancel);

            switch (exceptionType)
            {
            case TransferErrorType.NotSpecified:
            {
                if (feedbackNeeded)
                {
                    result = _skipAll ?? WindowManager.ShowIoErrorDialog(exception);
                }
                else
                {
                    WindowManager.ShowMessage(Resx.IOError, exception.Message);
                }
            }
            break;

            case TransferErrorType.WriteAccessError:
            case TransferErrorType.NotSupporterCharactersInPath:
            case TransferErrorType.NameIsTooLong:
            case TransferErrorType.PathIsTooLong:
            {
                if (_skipAll != null)
                {
                    result = _skipAll;
                }
                else
                {
                    if (_queue == null)
                    {
                        WindowManager.ShowMessage(Resx.IOError, exception.Message);
                    }
                    else
                    {
                        var sourceFile = _queue.Peek().FileSystemItem;
                        var viewModel  = WindowManager.GetWriteErrorDialogViewModel(transferException);
                        if (exceptionType == TransferErrorType.WriteAccessError)
                        {
                            if (IsResumeSupported && sourceFile.Size > transferException.TargetFileSize)
                            {
                                viewModel.IsResumeEnabled    = true;
                                viewModel.IsResumeAllEnabled = true;
                            }
                            if (transferException.TargetFile != null)
                            {
                                TargetPane.GetItemViewModel(transferException.TargetFile);
                            }
                        }
                        SourcePane.GetItemViewModel(sourceFile.Path);
                        result = WindowManager.ShowWriteErrorDialog(viewModel);
                    }
                }
            }
            break;

            case TransferErrorType.LostConnection:
                var ftp = (FtpContentViewModel)transferException.Pane;
                if (WindowManager.ShowReconnectionDialog(exception) == true)
                {
                    try
                    {
                        ftp.RestoreConnection();
                        ftp.Refresh(false);
                    }
                    catch (Exception ex)
                    {
                        WindowManager.ShowMessage(Resx.ConnectionFailed, string.Format(Resx.CannotReestablishConnection, ex.Message));
                        ftp.CloseCommand.Execute();
                    }
                }
                else
                {
                    ftp.CloseCommand.Execute();
                }
                break;

            default:
                throw new NotSupportedException("Invalid transfer error type: " + exceptionType);
            }

            //TODO: refactor scoping
            if (result.Scope == CopyActionScope.All)
            {
                if (result.Action.HasValue)
                {
                    _rememberedCopyAction = result.Action.Value;
                }
                if (result.Behavior == ErrorResolutionBehavior.Skip)
                {
                    _skipAll = result;
                }
            }
            _elapsedTimeMeter.Start();
            return(result);
        }