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))); }