public IPasteView Create(IRoom room, ClipboardItem clipboardItem)
{
var vm = _container.Resolve <IPasteViewModel>(new { room, clipboardItem });
var view = _container.Resolve <IPasteView>(new { vm });
return(view);
}
private void _listener_ClipboardChanged(object sender, EventArgs e)
{
if (Clipboard.ContainsText())
{
ClipboardItem ci = new ClipboardItem(Clipboard.GetText());
// if user pressed ctrl c in less then one second for same item,
// add the item in the history so user will be able to use it.
if (_lastItem != null &&
$"{ci.Item}" == $"{_lastItem.Item}" &&
$"{ci.Item}" != $"{(_history.Count > 0 ? _history.Peek()?.Item : null)}" &&
ci.Time.Subtract(_lastItem.Time).TotalMilliseconds < 1000)
{
_history.Push(ci);
}
_lastItem = ci;
}
if (Clipboard.ContainsFileDropList())
{
// todo Clipboard.GetFileDropList();
}
if (Clipboard.ContainsImage())
{
// todo Clipboard.GetImage();
}
if (Clipboard.ContainsAudio())
{
// todo Clipboard.GetAudioStream();
}
}
public ClipboardItem AddToClipboardHistory(object value)
{
if (value != null)
{
var content = (string)value;
if (content != "")
{
//iterate through history seeing if we already have this value if so remove it
var removeIndexes = new List<int>();
for (var i = 0; i < ClipboardHistory.Count; i++)
{
if (ClipboardHistory[i].Content == content)
{
removeIndexes.Add(i);
}
}
removeIndexes.ForEach(a => ClipboardHistory.RemoveAt(a));
//add the new content
var newClipboardItem = new ClipboardItem() { Content = content };
ClipboardHistory.Add(newClipboardItem);
UpdateHistoryLength();
return newClipboardItem;
}
else
{
return null;
}
}
else
{
return null;
}
}
public void TrySaveClipboardItem(ClipboardItem instance)
{
var res = ClipboardItems.Items;
var currentCount = res.Count;
if (currentCount < MaxClipboardHistory)
{
instance.Id = currentCount + 1;
Save(instance);
return;
}
var candidates = res
.Where(x => x.PasteCount <= instance.PasteCount && x.Clipped < instance.Clipped)
.Select(x => x);
var victim = candidates.OrderBy(x => x.PasteCount).ThenBy(x => x.Clipped).FirstOrDefault();
if (victim == null)
{
return;
}
instance.Id = victim.Id;
Save(instance);
}
public static ClipboardInfoResponse GetResponse(List <Guid> knownStateGuids)
{
return(new ClipboardInfoResponse
{
States = (knownStateGuids != null
? AppState.Current.ClipboardStates.Where(x => !knownStateGuids.Contains(x.Id))
: AppState.Current.ClipboardStates)
.Select(x =>
{
ClipboardItem item = ClipboardParser.GetPreferredItem(x.Items, serializable: true);
if (item != null)
{
return new ClipboardStateInfo
{
Id = x.Id,
Size = item.Size,
Format = ClipboardParser.GetAbstractFormat(item.Format),
DateTime = x.DateTime,
};
}
else
{
return null;
}
})
.Where(x => x != null)
.ToList(),
});
}
public static ClipboardStateResponse GetResponse(Guid stateId)
{
ClipboardState state = AppState.Current.ClipboardStates.FirstOrDefault(x => x.Id == stateId);
ClipboardItem item = state?.Items.FirstOrDefault(
x => ClipboardParser.CanSerialize(ClipboardParser.GetAbstractFormat(x.Format)));
if (state != null && item != null)
{
return(new ClipboardStateResponse
{
StateGuid = stateId,
Buffer = item.GetDataBuffer(),
Format = item.Format,
DateTime = state.DateTime,
IsError = false,
});
}
else
{
return(new ClipboardStateResponse
{
StateGuid = stateId,
Buffer = null,
Format = (DataFormat)0,
DateTime = state.DateTime,
IsError = true,
});
}
}
private ClipboardItemViewModel(IEnumerable <string> fileDropList)
{
_clipboardItem = new ClipboardItem
{
Text = fileDropList.Aggregate((s1, s2) => $"{s1}\n{s2}"),
DataType = Domain.ClipboardDataType.FileDrop
};
}
public Task SetClipboard(ClipboardItem clipboardItem)
{
RpcInvokeProxy.DispatchInvoke(() =>
{
Clipboards.SetClipboard(clipboardItem);
});
return(Task.CompletedTask);
}
private void SaveToBinFile(ClipboardItem clipboardItem)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ClipboardItem));
FileStream fileStream = File.Create(System.Windows.Forms.Application.StartupPath + "\\database.xml");
xmlSerializer.Serialize(fileStream, clipboardItem);
fileStream.Dispose();
}
public bool Update(ClipboardItem entity)
{
var index = _ctx.ClipBoardItems.FindIndex(x => x.Id == entity.Id);
_ctx.ClipBoardItems.RemoveAt(index);
_ctx.ClipBoardItems.Insert(index, entity);
return(_ctx.SaveChanges());
}
private void Add(ClipboardItem item)
{
if (string.IsNullOrWhiteSpace(item.Data.Text) && item.Data.Data == null)
{
return;
}
ClipboardItems.Add(item);
OnCountChanged(ClipboardItems.Count);
}
/// <summary>
/// Executes a copy operation awaits it and reloads the target folder into the cache.
/// </summary>
/// <param name="content">The item to be moved into the folder</param>
/// <param name="target">The target folder</param>
/// <param name="isRetrying">Determines if the method is retrying after an unauthorized response</param>
/// <exception cref="TaskCanceledException">Throws exception upon canceling the monitoring task</exception>
/// <returns>The pasted item</returns>
public async Task <DriveItem> ExecuteAsync(DriveItem content, DriveFolder target, bool isRetrying)
{
using (var client = new HttpClient())
{
var url = new Url(DriveService.BaseUrl)
.AppendPathSegments("items", content.Id, "copy");
var request = new HttpRequestMessage(HttpMethod.Post, url.ToUri());
request.Headers.Authorization = AuthService.Instance.CreateAuthenticationHeader();
var requestContent = new ClipboardItem
{
Name = content.Name,
ParentReference = new ParentReference
{
DriveId = DriveService.Instance.DriveId,
Id = target.Id
}
};
var json = JsonConvert.SerializeObject(requestContent);
request.Content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await Task.Run(() => client.SendAsync(request));
if (response.IsSuccessStatusCode)
{
var operationUri = response.Headers.Location;
// Adding cancellation token for the operation
var tokenSource = new CancellationTokenSource();
DriveService.Instance.CurrentOperations.Add(tokenSource);
// Waiting for the copying to end
var result = await DriveService.AwaitOperationAsync(operationUri, tokenSource.Token);
// Removing the cancellation token as the operation already ended
DriveService.Instance.CurrentOperations.Remove(tokenSource);
//This reloads the target folder into the cache to update its values
await DriveService.Instance.LoadItemAsync <DriveFolder>(target.Id);
// This results the item to be updated in the cache
return(await DriveService.Instance.GetItemAsync(result.ResourceId));
}
if (response.StatusCode == HttpStatusCode.Unauthorized && !isRetrying)
{
await AuthService.Instance.LoginAsync();
return(await ExecuteAsync(content, target, true));
}
throw new WebException(await response.Content.ReadAsStringAsync());
}
}
public void Save(ClipboardItem clipboardItem)
{
var existingEntry = ClipboardItems.Items.SingleOrDefault(x => x.Id == clipboardItem.Id);
if (existingEntry != null)
{
ClipboardItems.Items.Remove(existingEntry);
}
ClipboardItems.Items.Add(clipboardItem);
}
private ClipboardItemViewModel(BitmapSource bitmapSource)
{
_clipboardItem = new ClipboardItem
{
Text = "<img>",
DataType = Domain.ClipboardDataType.Image
};
Image = bitmapSource;
}
public PasteViewModel(ClipboardItem clipboardItem, IRoom room, IMessageBus bus)
{
if (clipboardItem.IsImage)
{
_imageSource = clipboardItem.LocalPath;
}
else
{
_imageSource = DependencyProperty.UnsetValue;
}
Caption = "Upload this " + (clipboardItem.IsImage ? "image" : "file") + "?";
LocalPath = clipboardItem.LocalPath;
ShowLocalPath = !clipboardItem.IsImage;
ContentType = clipboardItem.ContentType;
Size = clipboardItem.Size;
PasteCommand = new ReactiveCommand();
Subscribe(bus.Listen <FileUploadedMessage>().Where(msg => msg.CorrelationId == _currentCorrelation)
.SubscribeUI(_ => IsFinished = true));
Subscribe(bus.Listen <FileUploadProgressChangedMessage>().Where(msg => msg.CorrelationId == _currentCorrelation)
.SubscribeUI(
msg =>
{
ProgressCurrent = msg.Progress.Current;
ProgressTotal = msg.Progress.Total;
Debug.WriteLine("Current, total" + ProgressCurrent + ", " + ProgressTotal);
}));
Subscribe(bus.Listen <CorrelatedExceptionMessage>().Where(msg => msg.CorrelationId == _currentCorrelation)
.SubscribeUI(msg =>
{
IsErrored = true;
IsUploading = false;
LastException = msg.Exception;
}));
ProgressCurrent = 0;
ProgressTotal = 100;
Subscribe(bus.RegisterMessageSource(
PasteCommand.Do(_ =>
{
IsUploading = true;
IsErrored = false;
})
.Select(_ => new RequestUploadFileMessage(room.Id, clipboardItem.LocalPath, clipboardItem.ContentType))
.Do(msg => _currentCorrelation = msg.CorrelationId)));
CancelCommand = new ReactiveCommand();
Subscribe(CancelCommand.Subscribe(_ => IsFinished = true));
}
private object GetNext()
{
if (_history.Count == 0)
{
return(null);
}
ClipboardItem ci = _history.Pop();
_lastItem = _history.Count > 0 ? _history.Peek() : null;
return(ci.Item);
}
private ExportImageParams GetExportParams(ClipboardItem clipboardItem)
{
ExportImageParams exportParams = new ExportImageParams();
exportParams.ExportOption = ExportOption;
exportParams.DisplayRectangle = clipboardItem.DisplayRectangle;
exportParams.Scale = Scale;
exportParams.SizeMode = SizeMode;
exportParams.OutputSize = new Size(Width, Height);
exportParams.BackgroundColor = BackgroundColor;
return(exportParams);
}
private void ListViewUsers_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (ListViewUsers.SelectedIndex == -1)
{
return;
}
int index = ListViewUsers.SelectedIndex;
ClipboardItem selectedItem = ListViewUsers.SelectedItem as ClipboardItem;
Clipboard.SetText(selectedItem.Text);
ListViewUsers.SelectedItem = null;
MinimizeApplication();
}
internal static void Launch(IDesktopWindow desktopWindow, ClipboardItem clipboardItem)
{
Platform.CheckForNullReference(clipboardItem, "clipboardItem");
IDisplaySet displaySet = clipboardItem.Item as IDisplaySet;
if (displaySet == null)
{
throw new ArgumentException("The item being exported must be a display set.");
}
if (_progressComponentShelf != null)
{
desktopWindow.ShowMessageBox(SR.MessageVideoExportStillRunning, MessageBoxActions.Ok);
return;
}
if (displaySet.PresentationImages.Count <= 1)
{
desktopWindow.ShowMessageBox(SR.MessageDisplaySetTooFewImagesForVideo, MessageBoxActions.Ok);
return;
}
AviExportComponent component = new AviExportComponent(clipboardItem);
component.LoadSettings();
if (component.SelectedCodec == null)
{
desktopWindow.ShowMessageBox(SR.MessageNoAcceptableCodecsInstalled, MessageBoxActions.Ok);
return;
}
// give the width and height values from the item to be exported
foreach (IPresentationImage image in (displaySet.PresentationImages))
{
if (image is IImageGraphicProvider)
{
IImageGraphicProvider imageGraphicProvider = (IImageGraphicProvider)image;
component.Height = imageGraphicProvider.ImageGraphic.Rows;
component.Width = imageGraphicProvider.ImageGraphic.Columns;
break;
}
}
if (ApplicationComponentExitCode.Accepted != LaunchAsDialog(desktopWindow, component, SR.TitleExportToVideo))
{
return;
}
component.Export();
}
public void AddPasteFile(IRoom room, ClipboardItem clipboardItem)
{
var view = _pasteViewFactory.Create(room, clipboardItem);
var paragraph = new Paragraph();
paragraph.Inlines.Add(view.Element);
Blocks.Add(paragraph);
view.Closing.Subscribe(_ =>
{
Blocks.Remove(paragraph);
_pasteViewFactory.Release(view);
});
}
private static void ShowClipboardContents()
{
try
{
var item = new ClipboardItem();
if (item.Exists && !Instance.IsDuplicate(item))
{
Instance.ClipboardItems.Insert(0, item);
Instance.ListViewClipboardItems.SelectedIndex = 0;
}
}
catch (Exception excep)
{
}
}
private void Export()
{
if (SelectedImageExporter == null)
{
throw new InvalidOperationException("No exporter was chosen; unable to export any images.");
}
if (NumberOfImagesToExport == 1)
{
EventResult result = EventResult.Success;
AuditedInstances exportedInstances = GetInstancesForAudit(ItemsToExport, this.ExportFilePath);
try
{
if (!Directory.Exists(Path.GetDirectoryName(ExportFilePath ?? "")))
{
throw new FileNotFoundException("The specified export file path does not exist: " + ExportFilePath ?? "");
}
ClipboardItem clipboardItem = (ClipboardItem)_itemsToExport[0];
ExportImageParams exportParams = GetExportParams(clipboardItem);
SelectedImageExporter.Export((IPresentationImage)clipboardItem.Item, ExportFilePath, exportParams);
}
catch (Exception ex)
{
result = EventResult.SeriousFailure;
Platform.Log(LogLevel.Error, ex);
}
finally
{
AuditHelper.LogExportStudies(exportedInstances, EventSource.CurrentUser, result);
}
}
else
{
if (!Directory.Exists(ExportFilePath ?? ""))
{
throw new FileNotFoundException("The specified export directory does not exist." + ExportFilePath ?? "");
}
_multipleImageExporter = new MultipleImageExporter(this);
_multipleImageExporter.Run();
}
}
private void ListViewUsers_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
clipboardMonitor.OnClipboardContentChanged -= ClipboardMonitor_OnClipboardContentChanged;
if (ListViewUsers.SelectedIndex == -1)
{
return;
}
//int index = ListViewUsers.SelectedIndex;
ClipboardItem selectedItem = ListViewUsers.SelectedItem as ClipboardItem;
lastTextUsingEnterKey = selectedItem.Text;
Clipboard.SetText(lastTextUsingEnterKey);
ListViewUsers.SelectedItem = null;
MinimizeApplication();
clipboardMonitor.OnClipboardContentChanged += ClipboardMonitor_OnClipboardContentChanged;
}
}
/// <summary>
/// Moves the given item into the target folder, and also updates cache
/// </summary>
/// <param name="content">The item to be copied</param>
/// <param name="target">The target folder</param>
/// <param name="isRetrying">Determines if the method is retrying after an unauthorized response</param>
/// <returns>The pasted item</returns>
public async Task <DriveItem> ExecuteAsync(DriveItem content, DriveFolder target, bool isRetrying)
{
using (var client = new HttpClient())
{
var url = new Url(DriveService.BaseUrl)
.AppendPathSegments("items", content.Id);
var request = new HttpRequestMessage(new HttpMethod("PATCH"), url.ToUri());
request.Headers.Authorization = AuthService.Instance.CreateAuthenticationHeader();
var requestContent = new ClipboardItem
{
Name = content.Name,
ParentReference = new ParentReference
{
Id = target.Id
}
};
var json = JsonConvert.SerializeObject(requestContent);
request.Content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await Task.Run(() => client.SendAsync(request));
if (response.IsSuccessStatusCode)
{
DriveService.Instance.Cache.MoveItem(content.Id, target.Id);
return(content);
}
if (response.StatusCode != HttpStatusCode.Unauthorized && !isRetrying)
{
await AuthService.Instance.LoginAsync();
return(await ExecuteAsync(content, target, true));
}
throw new WebException(await response.Content.ReadAsStringAsync());
}
}
private void ClipboardMonitor_OnClipboardContentChanged(object sender, EventArgs e)
{
try
{
string clipboardText = Clipboard.GetText(TextDataFormat.UnicodeText);
if (clipboardText != lastText && clipboardText != "" && clipboardText != lastTextUsingEnterKey)
{
ClipboardItem clipboardItem = new ClipboardItem
{
Text = clipboardText,
Time = DateTime.Now
};
viewModel.Clipboards.Insert(0, clipboardItem);
//SaveToBinFile(clipboardItem);
lastText = clipboardText;
}
}
catch (Exception)
{
}
}
public static ClipboardNotifyChangedResponse GetResponse(IPAddress remoteIP, Guid stateId)
{
Task.Run(async() =>
{
var endPoint = new IPEndPoint(remoteIP, NetConfig.Port);
RemoteClipboardState host = null; // AppState.Current.RemoteClipboardStates.FirstOrDefault(x => x.Identity.EndPoint.Address.Equals(endPoint.Address));
if (host != null)
{
var res = await host.Identity.SendAsync(new ClipboardStateRequest(stateId));
if (res.IsError)
{
Logger.Default.LogWarn(LogEvents.NetErr, res);
}
else
{
host.States.Add(new ClipboardState(res.StateGuid, res.DateTime, new ClipboardItem[]
{
ClipboardItem.FromBuffer(res.Format, res.Buffer, cloneBuffer: false)
}));
}
}
});
return(new ClipboardNotifyChangedResponse());
}
public void SetImage()
{
_currentItem = new ClipboardItem("Test.png", "image/png");
}
internal void Delete(ClipboardItem item) => GetHistory().Delete(item);
private ExportImageParams GetExportParams(ClipboardItem clipboardItem)
{
return _exportComponent.GetExportParams(clipboardItem);
}
private ExportImageParams GetExportParams(ClipboardItem clipboardItem)
{
return(_exportComponent.GetExportParams(clipboardItem));
}
private void ListViewClipboardItems_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
this.ActiveItem = (ClipboardItem)((ListView)sender).SelectedItem;
this.ActiveItem.Write();
}
private bool IsDuplicate(ClipboardItem item)
{
return(this.ClipboardItems.Any(x => x.Equals(item)));
}
