# Gestire i connettori nelle presentazioni con Java

> Consenti alle app Java di disegnare, collegare e auto‑instradare linee nelle diapositive PowerPoint—ottieni il controllo completo su connettori lineari, a gomito e curvi.

Source: https://docs.aspose.com/slides/it/java/connector/
Updated: 2026-06-12

## **Introduzione**

Un connettore PowerPoint è una linea speciale che collega o unisce due forme e rimane attaccato alle forme anche quando queste vengono spostate o riposizionate su una determinata diapositiva.  

I connettori sono tipicamente collegati a *punti di connessione* (punti verdi), che esistono su tutte le forme per impostazione predefinita. I punti di connessione appaiono quando il cursore si avvicina.  

*Punti di regolazione* (punti arancioni), che esistono solo su alcuni connettori, sono usati per modificare le posizioni e le forme dei connettori.

## **Tipi di connettori**

In PowerPoint, è possibile utilizzare connettori lineari, a gomito (angolati) e curvi.  

Aspose.Slides fornisce questi connettori:

| Connettore | Image | Numero di punti di regolazione |
| ---------- | ----- | ------------------------------- |
| `ShapeType.Line` | ![shapetype-lineconnector](shapetype-lineconnector.png) | 0 |
| `ShapeType.StraightConnector1` | ![shapetype-straightconnector1](shapetype-straightconnector1.png) | 0 |
| `ShapeType.BentConnector2` | ![shapetype-bent-connector2](shapetype-bent-connector2.png) | 0 |
| `ShapeType.BentConnector3` | ![shapetype-bentconnector3](shapetype-bentconnector3.png) | 1 |
| `ShapeType.BentConnector4` | ![shapetype-bentconnector4](shapetype-bentconnector4.png) | 2 |
| `ShapeType.BentConnector5` | ![shapetype-bentconnector5](shapetype-bentconnector5.png) | 3 |
| `ShapeType.CurvedConnector2` | ![shapetype-curvedconnector2](shapetype-curvedconnector2.png) | 0 |
| `ShapeType.CurvedConnector3` | ![shapetype-curvedconnector3](shapetype-curvedconnector3.png) | 1 |
| `ShapeType.CurvedConnector4` | ![shapetype-curvedconnector4](shapetype-curvedconnector4.png) | 2 |
| `ShapeType.CurvedConnector5` | ![shapetype.curvedconnector5](shapetype.curvedconnector5.png) | 3 |

## **Collegare forme usando i connettori**

1. Crea un'istanza della classe [Presentation](https://apireference.aspose.com/slides/it/java/com.aspose.slides/Presentation).
1. Ottieni il riferimento a una diapositiva tramite il suo indice.
1. Aggiungi due [AutoShape](https://reference.aspose.com/slides/it/java/com.aspose.slides/AutoShape) alla diapositiva usando il metodo `addAutoShape` esposto dall'oggetto `Shapes`.
1. Aggiungi un connettore usando il metodo `addConnector` esposto dall'oggetto `Shapes` definendo il tipo di connettore.
1. Collega le forme usando il connettore.
1. Chiama il metodo `reroute` per applicare il percorso di connessione più breve.
1. Salva la presentazione.  

Questo codice Java mostra come aggiungere un connettore (un connettore piegato) tra due forme (un'ellisse e un rettangolo):

```Java
// Istanzia una classe di presentazione che rappresenta il file PPTX
Presentation pres = new Presentation();
try {
    // Accede alla raccolta di forme per una diapositiva specifica
    IShapeCollection shapes = pres.getSlides().get_Item(0).getShapes();
    
    // Aggiunge una forma automatica Ellisse
    IAutoShape ellipse = shapes.addAutoShape(ShapeType.Ellipse, 0, 100, 100, 100);
    
    // Aggiunge una forma automatica Rettangolo
    IAutoShape rectangle = shapes.addAutoShape(ShapeType.Rectangle, 100, 300, 100, 100);
    
    // Aggiunge una forma connettore alla raccolta di forme della diapositiva
    IConnector connector = shapes.addConnector(ShapeType.BentConnector2, 0, 0, 10, 10);
    
    // Collega le forme usando il connettore
    connector.setStartShapeConnectedTo(ellipse);
    connector.setEndShapeConnectedTo(rectangle);
    
    // Chiama reroute che imposta il percorso più breve automatico tra le forme
    connector.reroute();
    
    // Salva la presentazione
    pres.save("output.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

{{%  alert title="NOTE"  color="warning"   %}} 
Il metodo `Connector.reroute` riorienta un connettore e lo costringe a percorrere il percorso più breve possibile tra le forme. Per raggiungere questo scopo, il metodo può modificare i punti `setStartShapeConnectionSiteIndex` e `setEndShapeConnectionSiteIndex`. 
{{% /alert %}} 

## **Specificare un punto di connessione**

Se desideri che un connettore colleghi due forme usando punti specifici sulle forme, devi specificare i punti di connessione preferiti in questo modo:

1. Crea un'istanza della classe [Presentation](https://reference.aspose.com/slides/it/java/com.aspose.slides/Presentation).
1. Ottieni il riferimento a una diapositiva tramite il suo indice.
1. Aggiungi due [AutoShape](https://reference.aspose.com/slides/it/java/com.aspose.slides/AutoShape) alla diapositiva usando il metodo `addAutoShape` esposto dall'oggetto `Shapes`.
1. Aggiungi un connettore usando il metodo `addConnector` esposto dall'oggetto `Shapes` definendo il tipo di connettore.
1. Collega le forme usando il connettore.
1. Imposta i punti di connessione preferiti sulle forme.
1. Salva la presentazione.  

Questo codice Java dimostra un'operazione in cui viene specificato un punto di connessione preferito:

```java
// Istanzia una classe di presentazione che rappresenta un file PPTX
Presentation pres = new Presentation();
try {
    // Accede alla raccolta di forme per una diapositiva specifica
    IShapeCollection shapes = pres.getSlides().get_Item(0).getShapes();

    // Aggiunge una forma automatica Ellisse
    IAutoShape ellipse = shapes.addAutoShape(ShapeType.Ellipse, 0, 100, 100, 100);

    // Aggiunge una forma automatica Rettangolo
    IAutoShape rectangle = shapes.addAutoShape(ShapeType.Rectangle, 100, 300, 100, 100);

    // Aggiunge una forma connettore alla raccolta di forme della diapositiva
    IConnector connector = shapes.addConnector(ShapeType.BentConnector2, 0, 0, 10, 10);

    // Collega le forme usando il connettore
    connector.setStartShapeConnectedTo(ellipse);
    connector.setEndShapeConnectedTo(rectangle);

    // Imposta l'indice del punto di connessione preferito sulla forma Ellisse
    int wantedIndex = 6;

    // Verifica se l'indice preferito è minore del conteggio massimo dei punti di connessione
    if (ellipse.getConnectionSiteCount() > wantedIndex) 
    {
        // Imposta il punto di connessione preferito sulla forma automatica Ellisse
        connector.setStartShapeConnectionSiteIndex(wantedIndex);
    }

    // Salva la presentazione
    pres.save("output.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Regolare un punto del connettore**

Puoi regolare un connettore esistente tramite i suoi punti di regolazione. Solo i connettori con punti di regolazione possono essere modificati in questo modo. Vedi la tabella sotto **[Types of connectors.](/slides/it/java/connector/#types-of-connectors)** 

### **Caso semplice**

Considera un caso in cui un connettore tra due forme (A e B) passa attraverso una terza forma (C):

![connector-obstruction](connector-obstruction.png)

```java
Presentation pres = new Presentation();
try {

    ISlide sld = pres.getSlides().get_Item(0);
    IShape shape = sld.getShapes().addAutoShape(ShapeType.Rectangle, 300, 150, 150, 75);
    IShape shapeFrom = sld.getShapes().addAutoShape(ShapeType.Rectangle, 500, 400, 100, 50);
    IShape shapeTo = sld.getShapes().addAutoShape(ShapeType.Rectangle, 100, 100, 70, 30);

    IConnector connector = sld.getShapes().addConnector(ShapeType.BentConnector5, 20, 20, 400, 300);

    connector.getLineFormat().setEndArrowheadStyle(LineArrowheadStyle.Triangle);
    connector.getLineFormat().getFillFormat().setFillType(FillType.Solid);
    connector.getLineFormat().getFillFormat().getSolidFillColor().setColor(Color.BLACK);

    connector.setStartShapeConnectedTo(shapeFrom);
    connector.setEndShapeConnectedTo(shapeTo);
    connector.setStartShapeConnectionSiteIndex(2);
} finally {
    if (pres != null) pres.dispose();
}
```

Per evitare o aggirare la terza forma, possiamo regolare il connettore spostando la sua linea verticale verso sinistra in questo modo:

![connector-obstruction-fixed](connector-obstruction-fixed.png)

```java
IAdjustValue adj2 = connector.getAdjustments().get_Item(1);
adj2.setRawValue(adj2.getRawValue() + 10000);
```

### **Casi complessi** 

Per eseguire regolazioni più complesse, devi tenere in considerazione i seguenti aspetti:

* Il punto regolabile di un connettore è strettamente legato a una formula che calcola e determina la sua posizione. Pertanto, le modifiche alla posizione del punto possono alterare la forma del connettore.
* I punti di regolazione di un connettore sono definiti in un ordine rigoroso in un array. I punti sono numerati dal punto di partenza del connettore fino al suo punto finale.
* I valori dei punti di regolazione riflettono la percentuale della larghezza/altezza della forma del connettore.
  * La forma è delimitata dai punti di inizio e fine del connettore moltiplicati per 1000.
  * Il primo punto, il secondo punto e il terzo punto definiscono rispettivamente la percentuale rispetto alla larghezza, la percentuale rispetto all'altezza e nuovamente la percentuale rispetto alla larghezza.
* Per i calcoli che determinano le coordinate dei punti di regolazione di un connettore, devi considerare la rotazione del connettore e il suo riflesso. **Nota** che l'angolo di rotazione per tutti i connettori mostrati sotto **[Types of connectors](/slides/it/java/connector/#types-of-connectors)** è 0.

#### **Caso 1**

Considera un caso in cui due oggetti di riquadro di testo sono collegati insieme tramite un connettore:

![connector-shape-complex](connector-shape-complex.png)

```java
// Istanzia una classe di presentazione che rappresenta un file PPTX
Presentation pres = new Presentation();
try {
    // Ottiene la prima diapositiva nella presentazione
    ISlide sld = pres.getSlides().get_Item(0);
    // Aggiunge forme che saranno unite tramite un connettore
    IAutoShape shapeFrom = sld.getShapes().addAutoShape(ShapeType.Rectangle, 100, 100, 60, 25);
    shapeFrom.getTextFrame().setText("From");
    IAutoShape shapeTo = sld.getShapes().addAutoShape(ShapeType.Rectangle, 500, 100, 60, 25);
    shapeTo.getTextFrame().setText("To");
    // Aggiunge un connettore
    IConnector connector = sld.getShapes().addConnector(ShapeType.BentConnector4, 20, 20, 400, 300);
    // Specifica la direzione del connettore
    connector.getLineFormat().setEndArrowheadStyle(LineArrowheadStyle.Triangle);
    // Specifica il colore del connettore
    connector.getLineFormat().getFillFormat().setFillType(FillType.Solid);
    connector.getLineFormat().getFillFormat().getSolidFillColor().setColor(Color.RED);
    // Specifica lo spessore della linea del connettore
    connector.getLineFormat().setWidth(3);
    
    // Collega le forme insieme con il connettore
    connector.setStartShapeConnectedTo(shapeFrom);
    connector.setStartShapeConnectionSiteIndex(3);
    connector.setEndShapeConnectedTo(shapeTo);
    connector.setEndShapeConnectionSiteIndex(2);
    
    // Ottiene i punti di regolazione per il connettore
    IAdjustValue adjValue_0 = connector.getAdjustments().get_Item(0);
    IAdjustValue adjValue_1 = connector.getAdjustments().get_Item(1);

} finally {
    if (pres != null) pres.dispose();
}
```

**Regolazione**

Possiamo modificare i valori dei punti di regolazione del connettore aumentando rispettivamente la percentuale di larghezza e di altezza del 20% e del 200%:

```java
// Modifica i valori dei punti di regolazione
adjValue_0.setRawValue(adjValue_0.getRawValue() + 20000);
adjValue_1.setRawValue(adjValue_1.getRawValue() + 200000);
```

Il risultato:

![connector-adjusted-1](connector-adjusted-1.png)

Per definire un modello che ci permetta di determinare le coordinate e la forma delle singole parti del connettore, creiamo una forma che corrisponda alla componente orizzontale del connettore al punto `connector.getAdjustments().get_Item(0)`:

```java
// Disegna la componente verticale del connettore
float x = connector.getX() + connector.getWidth() * adjValue_0.getRawValue() / 100000;
float y = connector.getY();
float height = connector.getHeight() * adjValue_1.getRawValue() / 100000;
sld.getShapes().addAutoShape( ShapeType .Rectangle, x, y, 0, height);
```

Il risultato:

![connector-adjusted-2](connector-adjusted-2.png)

#### **Caso 2**

Nel **Caso 1**, abbiamo dimostrato un'operazione di regolazione semplice del connettore usando principi di base. In situazioni normali, devi considerare la rotazione del connettore e la sua visualizzazione (impostate da `connector.getRotation()`, `connector.getFrame().getFlipH()` e `connector.getFrame().getFlipV()`). Ora dimostreremo il processo.

Per prima cosa, aggiungiamo un nuovo oggetto di riquadro di testo (**To 1**) alla diapositiva (per scopi di collegamento) e creiamo un nuovo connettore (verde) che lo collega agli oggetti che abbiamo già creato.

```java
// Crea un nuovo oggetto di binding
IAutoShape shapeTo_1 = sld.getShapes().addAutoShape(ShapeType.Rectangle, 100, 400, 60, 25);
shapeTo_1.getTextFrame().setText("To 1");
// Crea un nuovo connettore
connector = sld.getShapes().addConnector(ShapeType.BentConnector4, 20, 20, 400, 300);
connector.getLineFormat().setEndArrowheadStyle(LineArrowheadStyle.Triangle);
connector.getLineFormat().getFillFormat().setFillType(FillType.Solid);
connector.getLineFormat().getFillFormat().getSolidFillColor().setColor(Color.CYAN);
connector.getLineFormat().setWidth(3);
// Collega gli oggetti usando il connettore appena creato
connector.setStartShapeConnectedTo(shapeFrom);
connector.setStartShapeConnectionSiteIndex(2);
connector.setEndShapeConnectedTo(shapeTo_1);
connector.setEndShapeConnectionSiteIndex(3);
// Ottiene i punti di regolazione del connettore
adjValue_0 = connector.getAdjustments().get_Item(0);
adjValue_1 = connector.getAdjustments().get_Item(1);
// Modifica i valori dei punti di regolazione
adjValue_0.setRawValue(adjValue_0.getRawValue() + 20000);
adjValue_1.setRawValue(adjValue_1.getRawValue() + 200000);
```

Il risultato:

![connector-adjusted-3](connector-adjusted-3.png)

Secondo, creiamo una forma che corrisponda alla componente orizzontale del connettore che passa attraverso il nuovo punto di regolazione del connettore `connector.getAdjustments().get_Item(0)`. Useremo i valori dei dati del connettore per `connector.getRotation()`, `connector.getFrame().getFlipH()` e `connector.getFrame().getFlipV()` e applicheremo la nota formula di conversione delle coordinate per rotazione attorno a un punto dato x0:

X = (x — x0) * cos(alpha) — (y — y0) * sin(alpha) + x0;
Y = (x — x0) * sin(alpha) + (y — y0) * cos(alpha) + y0;

Nella nostra situazione, l'angolo di rotazione dell'oggetto è 90 gradi e il connettore è visualizzato verticalmente, quindi ecco il codice corrispondente:

```java
// Salva le coordinate del connettore
x = connector.getX();
y = connector.getY();
// Corregge le coordinate del connettore nel caso appaia
if (connector.getFrame().getFlipH() == NullableBool.True)
{
    x += connector.getWidth();
}
if (connector.getFrame().getFlipV() == NullableBool.True)
{
    y += connector.getHeight();
}
// Prende il valore del punto di regolazione come coordinata
x += connector.getWidth() * adjValue_0.getRawValue() / 100000;
//  Converte le coordinate poiché Sin(90) = 1 e Cos(90) = 0
float xx = connector.getFrame().getCenterX() - y + connector.getFrame().getCenterY();
float yy = x - connector.getFrame().getCenterX() + connector.getFrame().getCenterY();
// Determina la larghezza della componente orizzontale usando il valore del secondo punto di regolazione
float width = connector.getHeight() * adjValue_1.getRawValue() / 100000;
IAutoShape shape = sld.getShapes().addAutoShape(ShapeType.Rectangle, xx, yy, width, 0);
shape.getLineFormat().getFillFormat().setFillType(FillType.Solid);
shape.getLineFormat().getFillFormat().getSolidFillColor().setColor(Color.RED);
```

Il risultato:

![connector-adjusted-4](connector-adjusted-4.png)

Abbiamo dimostrato calcoli che coinvolgono regolazioni semplici e punti di regolazione complessi (punti di regolazione con angoli di rotazione). Utilizzando le conoscenze acquisite, puoi sviluppare il tuo modello (o scrivere del codice) per ottenere un oggetto `GraphicsPath` o anche impostare i valori dei punti di regolazione di un connettore in base a coordinate specifiche della diapositiva.

## **Trovare l'angolo delle linee di connettore**

1. Crea un'istanza della classe.
1. Ottieni il riferimento a una diapositiva tramite il suo indice.
1. Accedi alla forma della linea del connettore.
1. Usa la larghezza e l'altezza della linea, l'altezza del frame della forma e la larghezza del frame della forma per calcolare l'angolo.  

Questo codice Java dimostra un'operazione in cui abbiamo calcolato l'angolo per una forma di linea di connettore:

```java
Presentation pres = new Presentation("ConnectorLineAngle.pptx");
try {
    Slide slide = (Slide)pres.getSlides().get_Item(0);
    
    for (int i = 0; i < slide.getShapes().size(); i++)
    {
        double dir = 0.0;
        Shape shape = (Shape)slide.getShapes().get_Item(i);
        if (shape instanceof AutoShape)
        {
            AutoShape ashp = (AutoShape)shape;
            if (ashp.getShapeType() == ShapeType.Line)
            {
                dir = getDirection(ashp.getWidth(), ashp.getHeight(),
                        ashp.getFrame().getFlipH() > 0, ashp.getFrame().getFlipV() > 0);
            }
        }
        else if (shape instanceof Connector)
        {
            Connector ashp = (Connector)shape;
            dir = getDirection(ashp.getWidth(), ashp.getHeight(),
                    ashp.getFrame().getFlipH() > 0, ashp.getFrame().getFlipV() > 0);
        }

        System.out.println(dir);
    }
} finally {
    if (pres != null) pres.dispose();
}
```
```java
public static double getDirection(float w, float h, boolean flipH, boolean flipV)
{
    float endLineX = w * (flipH ? -1 : 1);
    float endLineY = h * (flipV ? -1 : 1);
    float endYAxisX = 0;
    float endYAxisY = h;
    double angle = (Math.atan2(endYAxisY, endYAxisX) - Math.atan2(endLineY, endLineX));
    if (angle < 0) angle += 2 * Math.PI;
    return angle * 180.0 / Math.PI;
}
```

## **FAQ**

**Come posso capire se un connettore può essere "incollato" a una forma specifica?**

Verifica che la forma esponga [punti di connessione](https://reference.aspose.com/slides/it/java/com.aspose.slides/shape/#getConnectionSiteCount--). Se non ce ne sono o il conteggio è zero, l'incollaggio non è disponibile; in tal caso, usa estremità libere e posizionale manualmente. È consigliabile controllare il numero di punti prima di attaccare.

**Cosa succede a un connettore se elimino una delle forme collegate?**

I suoi estremi si staccheranno; il connettore rimane nella diapositiva come una linea ordinaria con inizio/fine liberi. Puoi cancellarlo oppure riassegnare le connessioni e, se necessario, [reroute](https://reference.aspose.com/slides/it/java/com.aspose.slides/connector/#reroute--).

**I collegamenti dei connettori vengono conservati quando si copia una diapositiva in un'altra presentazione?**

Generalmente sì, a condizione che le forme target vengano copiate anch'esse. Se la diapositiva viene inserita in un altro file senza le forme collegate, le estremità diventano libere e dovrai ricollegarle.