Come selezionare o evidenziare il testo sull'evento di spostamento del mouse in WritableBitmap in wpf C#

Question

Ho l'immagine WritableBitmap e ho impostato il controllo immagine src. Sto creando rettangolo quando l'utente si sposta nell'area di testo selezionata. Sto anche usando PDFtron SDK per ottenere il testo selezionato dal documento PDF. stiamo ottenendo l'immagine WritableBitmap da PDF. Dobbiamo selezionare il testo in linea.

Sto usando questo codice per disegnare lo schermo:

System.Drawing.Rectangle rectangle = new System.Drawing.Rectangle((int)Math.Min(_downX, x), 
          (int)Math.Min(_downY, y), 
          (int)Math.Abs(_downX - x), 
          (int)Math.Abs(_downY - y)); 

System.Drawing.Bitmap myBitmap = new System.Drawing.Bitmap(@"D:\PDF\ScreenDraw\WpfApplication1\WpfApplication1\Image\Capture.PNG"); 

using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(myBitmap)) 
{ 
    System.Drawing.Color customColor = System.Drawing.Color.FromArgb(50, System.Drawing.Color.Red); 
    System.Drawing.SolidBrush shadowBrush = new System.Drawing.SolidBrush(customColor); 
    g.FillRectangles(shadowBrush, new System.Drawing.Rectangle[] { rectangle }); 
} 

//myBitmap.Save(@"D:\PDF\abc.png"); 
//bitmapSource = new BitmapImage(new Uri(@"D:\PDF\abc.png", UriKind.Absolute)); 

using (var memory = new System.IO.MemoryStream()) 
{ 
    myBitmap.Save(memory, System.Drawing.Imaging.ImageFormat.Png); 
    memory.Position = 0; 

    var bitmapImage = new BitmapImage(); 
    bitmapImage.BeginInit(); 
    bitmapImage.StreamSource = memory; 
    bitmapImage.CacheOption = BitmapCacheOption.OnLoad; 
    bitmapImage.EndInit(); 
    Img.Source = bitmapImage; 
} 

Come posso selezionare il testo con la linea di saggio non un Rect saggio?

Devo selezionare il testo come mostrato nell'immagine sopra.

Answer 1

Quello che vuoi è impossibile. Hai una bitmap e non è magicamente a conoscenza del testo in esso e nulla lo cambierà. Anche se non è che non ci sia nulla che tu possa fare al riguardo. Non ho tempo di fornire una soluzione completa, ma posso fornire istruzioni passo-passo su come ottenere la migliore soluzione possibile.

Che cosa si può fare è:

1. dimensioni testo di definizione - Creare il controllo con griglia sovrapposta l'immagine con X- modificabile e passo Y e offset. Quindi sarai in grado di calibrare la griglia con le linee di testo (Y). E la larghezza del carattere (X). Qualcosa del genere dovrebbe fare (credo si otterrà l'idea generale):

   public int XGridStep 
   { 
       get { return (int)base.GetValue(XGridStepProperty); } 
       set 
       { 
        base.SetValue(XGridStepProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty XGridStepProperty = DependencyProperty.Register("XGridStepProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(100)); 
   
   public int XGridOffset 
   { 
       get { return (int)base.GetValue(XGridOffsetProperty); } 
       set 
       { 
        base.SetValue(XGridOffsetProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty XGridOffsetProperty = DependencyProperty.Register("XGridOffsetProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(0)); 
   
   public bool XGridVisible 
   { 
       get { return (bool)base.GetValue(XGridVisibleProperty); } 
       set 
       { 
        base.SetValue(XGridVisibleProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty XGridVisibleProperty = DependencyProperty.Register("XGridVisibleProperty", typeof(bool), typeof(PlanLayout), new PropertyMetadata(false)); 
   
   public int YGridStep 
   { 
       get { return (int)base.GetValue(YGridStepProperty); } 
       set 
       { 
        base.SetValue(YGridStepProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty YGridStepProperty = DependencyProperty.Register("YGridStepProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(100)); 
   
   public int YGridOffset 
   { 
       get { return (int)base.GetValue(YGridOffsetProperty); } 
       set 
       { 
        base.SetValue(YGridOffsetProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty YGridOffsetProperty = DependencyProperty.Register("YGridOffsetProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(0)); 
   
   public bool YGridVisible 
   { 
       get { return (bool)base.GetValue(YGridVisibleProperty); } 
       set 
       { 
        base.SetValue(YGridVisibleProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty YGridVisibleProperty = DependencyProperty.Register("YGridVisibleProperty", typeof(bool), typeof(PlanLayout), new PropertyMetadata(false)); 
   
   private void RepaintGrid() 
   { 
       if (!IsEditable) 
        return; 
   
       foreach (Line l in _gridXLines) 
        content.Children.Remove(l); 
       _gridXLines.Clear(); 
       if (XGridVisible) 
        for (int i = XGridOffset; i < content.ActualWidth; i += XGridStep) 
        { 
         Line line = new Line(); 
         line.IsHitTestVisible = false; 
         line.Stroke = Brushes.Black; 
         line.Y1 = 0; 
         line.Y2 = content.ActualHeight; 
         line.X1 = line.X2 = i; 
         if (Math.Abs(line.X1 - content.ActualWidth) < XGridStep * 0.5 || line.X1 < XGridStep * 0.5) 
          continue; 
         _gridXLines.Add(line); 
         content.Children.Add(line); 
         Canvas.SetZIndex(line, 0); 
        } 
   
       foreach (Line l in _gridYLines) 
        content.Children.Remove(l); 
       _gridYLines.Clear(); 
       if (YGridVisible) 
        for (int i = YGridOffset; i < content.ActualHeight; i += YGridStep) 
        { 
         Line line = new Line(); 
         line.IsHitTestVisible = false; 
         line.Stroke = Brushes.Black; 
         line.X1 = 0; 
         line.X2 = content.ActualWidth; 
         line.Y1 = line.Y2 = i; 
         if (Math.Abs(line.Y1 - content.ActualHeight) < YGridStep * 0.5 || line.Y1 < YGridStep * 0.5) 
          continue; 
         _gridYLines.Add(line); 
         content.Children.Add(line); 
         Canvas.SetZIndex(line, 0); 
        } 
   } 
   

2. selezione Testo - Tutto quello che dovete fare ora è aggiungere "Allinea alla griglia" capacità di controllo. Anche in questo caso, solo per riferimento:

   private void elementWrapper_MouseMove(object sender, System.Windows.Input.MouseEventArgs e) 
   { 
       if (_mouseHandlingMode != MouseHandlingMode.Dragging) 
        return; 
   
       SelectableElement element = (SelectableElement)sender; 
   
       Point curContentPoint = e.GetPosition(content); 
       //Vector elementDragVector = curContentPoint - _origContentMouseDownPoint; 
   
       _origContentMouseDownPoint = curContentPoint; 
   
       //double destinationLeft = Canvas.GetLeft(element) + elementDragVector.X; 
       //double destinationTop = Canvas.GetTop(element) + elementDragVector.Y; 
       double destinationLeft = curContentPoint.X - element.ActualWidth/2; 
       double destinationTop = curContentPoint.Y - element.ActualHeight/2; 
   
       if (SnapToGrid) 
       { 
        if (XGridVisible) 
        { 
         foreach (Line l in _gridXLines) 
          l.StrokeThickness = 1; 
   
         Line nearest = GetNearestXGridLine((int)curContentPoint.X); 
   
         if (Math.Abs(curContentPoint.X - nearest.X1) < XGridStep * 0.2) 
         { 
          destinationLeft = nearest.X1 - element.ActualWidth/2; 
          nearest.StrokeThickness = 3; 
         } 
        } 
   
        if (YGridVisible) 
        { 
         foreach (Line l in _gridYLines) 
          l.StrokeThickness = 1; 
   
         Line nearest = GetNearestYGridLine((int)curContentPoint.Y); 
   
         if (Math.Abs(curContentPoint.Y - nearest.Y1) < YGridStep * 0.2) 
         { 
          destinationTop = nearest.Y1 - element.ActualHeight/2; 
          nearest.StrokeThickness = 3; 
         } 
        } 
       } 
   
       if (destinationLeft < 0) 
        destinationLeft = 0; 
   
       if (destinationLeft > content.ActualWidth - element.ActualWidth) 
        destinationLeft = content.ActualWidth - element.ActualWidth; 
   
       if (destinationTop < 0) 
        destinationTop = 0; 
   
       if (destinationTop > content.ActualHeight - element.ActualHeight) 
        destinationTop = content.ActualHeight - element.ActualHeight; 
   
       Canvas.SetLeft(element, destinationLeft); 
       Canvas.SetTop(element, destinationTop); 
   
       element.ElementContent.Position.X = curContentPoint.X; 
       element.ElementContent.Position.Y = curContentPoint.Y; 
   
       e.Handled = true; 
   } 
   
   private Line GetNearestXGridLine(int xpos) 
   { 
       return _gridXLines.OrderBy(gl => Math.Abs((int)gl.X1 - xpos)).First(); 
   } 
   
   private Line GetNearestYGridLine(int Ypos) 
   { 
       return _gridYLines.OrderBy(gl => Math.Abs((int)gl.Y1 - Ypos)).First(); 
   } 
   

3. Rappresentazione grafica della selezione - Ora disegnate (fino a) 3 rettangoli: dal punto topleft della selezione bottomright punto della riga di testo in questione, punto topleft del linea successiva al punto più basso della linea prima dell'ultimo punto selezionato e topleft dell'ultima riga verso il basso della selezione

4. Ottieni testo - Ottieni dati di testo parziale da questi rettangoli e partecipa.