Personalizar Formas de Apresentação no Android
Visão geral
Este artigo explica como personalizar formas de apresentação no Aspose.Slides editando a geometria da forma por meio de pontos de edição e caminhos de geometria. Ele demonstra como trabalhar com GeometryPath e IGeometryPath para modificar formas existentes, executar operações básicas de edição de caminho, adicionar ou remover pontos e aplicar a geometria atualizada de volta a uma forma.
Também demonstra como criar formas personalizadas e compostas, construir formas com cantos curvos, determinar se a geometria de uma forma está fechada e inspecionar elementos de forma usando arrays de pontos Android.
Alterar uma Forma Usando Pontos de Edição
No PowerPoint, você pode usar Pontos de Edição para modificar um quadrado:
- Mover um canto para dentro ou para fora.
- Ajustar a curvatura em um ponto.
- Adicionar novos pontos.
Editar pontos permite que você modifique o contorno de uma forma ou use uma forma existente como base para uma nova.
Dicas de Edição de Forma
Ao editar formas do PowerPoint, mantenha esses conceitos em mente:
- Uma forma (ou seu caminho) pode ser fechada ou aberta.
- O caminho de uma forma consiste em pontos de ancoragem conectados por segmentos.
- Um segmento pode ser reto ou curvo. Pontos de ancoragem e alças de controle determinam sua forma.
- Os pontos de ancoragem podem ser pontos de canto, pontos retos ou pontos suaves:
- Em um ponto de canto, os segmentos adjacentes podem se encontrar em um ângulo.
- Em um ponto suave, as duas alças de controle estão alinhadas e a mesma distância do ponto de ancoragem.
- Em um ponto reto, as duas alças de controle estão alinhadas, mas podem ter distâncias diferentes do ponto de ancoragem.
- Mover os pontos de ancoragem ou ajustar suas alças altera o contorno da forma.
Para editar formas do PowerPoint por meio de pontos de edição, Aspose.Slides fornece a classe GeometryPath e a interface IGeometryPath.
- Uma instância de GeometryPath representa um caminho de geometria do objeto IGeometryShape.
- Para obter o GeometryPath a partir da instância de IGeometryShape, você pode usar o método IGeometryShape.getGeometryPaths.
- Para definir o GeometryPath de uma forma, você pode usar estes métodos: IGeometryShape.setGeometryPath para formas com um único caminho e IGeometryShape.setGeometryPaths para formas com múltiplos caminhos.
- Para adicionar segmentos, você pode usar os métodos da interface IGeometryPath.
- Usando os métodos IGeometryPath.setStroke e IGeometryPath.setFillMode, você pode definir a aparência de um caminho de geometria.
- Usando o método IGeometryPath.getPathData, você pode recuperar o caminho de geometria de um GeometryShape como um array de segmentos de caminho.
Operações Simples de Edição
Use os métodos a seguir para editar um caminho de geometria. Sobrecargas que aceitam um índice inserem um segmento naquela posição baseada em zero no array de segmentos do caminho.
| Operação | Método |
|---|---|
| Adicionar ou inserir uma linha reta. | GeometryPath.lineTo |
| Adicionar ou inserir uma curva Bézier cúbica com dois pontos de controle e um ponto final. | GeometryPath.cubicBezierTo |
| Adicionar ou inserir uma curva Bézier quadrática com um ponto de controle e um ponto final. | GeometryPath.quadraticBezierTo |
| Adicionar um arco elíptico com as dimensões e ângulos especificados em graus. | GeometryPath.arcTo |
| Fechar a figura atual conectando seu ponto final ao ponto inicial. | GeometryPath.closeFigure |
| Definir o ponto de partida de uma figura. | GeometryPath.moveTo |
| Remover um segmento em um índice baseado em zero. | GeometryPath.removeAt |
Adicionar Pontos Personalizados a uma Forma
Este exemplo insere dois pontos em uma forma retangular usando GeometryPath.lineTo e aplica o caminho editado com IGeometryShape.setGeometryPath. As coordenadas são locais à forma: ambos os novos pontos estão em seu centro, 100 pontos da esquerda e 50 pontos do topo. Os índices de segmento 1 e 4 posicionam-nos nas bordas superior e inferior, puxando essas bordas para dentro.
import com.aspose.slides.*;
Presentation presentation = new Presentation();
try {
ISlide slide = presentation.getSlides().get_Item(0);
IAutoShape shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 100, 100, 200, 100);
IGeometryPath geometryPath = shape.getGeometryPaths()[0];
geometryPath.lineTo(100, 50, 1);
geometryPath.lineTo(100, 50, 4);
shape.setGeometryPath(geometryPath);
} finally {
presentation.dispose();
}
Remover Pontos de uma Forma
Este exemplo altera o contorno de uma forma em forma de coração removendo o segmento no índice baseado em zero 2 com GeometryPath.removeAt. Aplicar o caminho modificado com IGeometryShape.setGeometryPath atualiza o contorno da forma.
import com.aspose.slides.*;
Presentation presentation = new Presentation();
try {
ISlide slide = presentation.getSlides().get_Item(0);
IAutoShape shape = slide.getShapes().addAutoShape(ShapeType.Heart, 100, 100, 300, 300);
IGeometryPath path = shape.getGeometryPaths()[0];
path.removeAt(2);
shape.setGeometryPath(path);
} finally {
presentation.dispose();
}
Criar uma Forma Personalizada
Este exemplo constrói uma estrela de cinco pontas com GeometryPath. Raios externos e internos alternados de 100 e 50 pontos definem as pontas e as entalhes; um passo de 72 graus espaça as cinco pontas uniformemente. O caminho é fechado com GeometryPath.closeFigure e aplicado a uma forma retangular usando IGeometryShape.setGeometryPath, substituindo seu contorno.
import com.aspose.slides.*;
import android.graphics.PointF;
import java.util.ArrayList;
import java.util.List;
List<PointF> points = new ArrayList<>();
float outerRadius = 100f;
float innerRadius = 50f;
int angleStep = 72;
for (int angle = -90; angle < 270; angle += angleStep)
{
double radians = angle * (Math.PI / 180f);
double x = outerRadius * Math.cos(radians);
double y = outerRadius * Math.sin(radians);
PointF point = new PointF((float)x + outerRadius, (float)y + outerRadius);
points.add(point);
radians = Math.PI * (angle + angleStep / 2) / 180.0;
x = innerRadius * Math.cos(radians);
y = innerRadius * Math.sin(radians);
point = new PointF((float)x + outerRadius, (float)y + outerRadius);
points.add(point);
}
GeometryPath starPath = new GeometryPath();
starPath.moveTo(points.get(0));
for (int i = 1; i < points.size(); i++)
{
starPath.lineTo(points.get(i));
}
starPath.closeFigure();
Presentation presentation = new Presentation();
try {
ISlide slide = presentation.getSlides().get_Item(0);
IAutoShape shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 100, 100, outerRadius * 2, outerRadius * 2);
shape.setGeometryPath(starPath);
} finally {
presentation.dispose();
}
Criar uma Forma Personalizada Composta
Este exemplo define dois GeometryPath fechados para o terço superior e inferior de uma forma. Aplicar ambos os caminhos com IGeometryShape.setGeometryPaths cria uma única forma composta com uma lacuna através do terço central.
import com.aspose.slides.*;
Presentation presentation = new Presentation();
try {
ISlide slide = presentation.getSlides().get_Item(0);
IAutoShape shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 100, 100, 200, 100);
GeometryPath topPath = new GeometryPath();
topPath.moveTo(0, 0);
topPath.lineTo(shape.getWidth(), 0);
topPath.lineTo(shape.getWidth(), shape.getHeight() / 3);
topPath.lineTo(0, shape.getHeight() / 3);
topPath.closeFigure();
GeometryPath bottomPath = new GeometryPath();
bottomPath.moveTo(0, shape.getHeight() / 3 * 2);
bottomPath.lineTo(shape.getWidth(), shape.getHeight() / 3 * 2);
bottomPath.lineTo(shape.getWidth(), shape.getHeight());
bottomPath.lineTo(0, shape.getHeight());
bottomPath.closeFigure();
shape.setGeometryPaths(new GeometryPath[] { topPath, bottomPath });
} finally {
presentation.dispose();
}
Criar uma Forma Personalizada com Cantos Curvos
Este exemplo combina segmentos retos com GeometryPath.arcTo para criar uma forma com cantos curvados para dentro. Cada tamanho de canto define a largura e a altura do arco em pontos, e o varrimento de –90 graus desenha um quarto de elipse no sentido anti‑horário. O caminho concluído é aplicado com IGeometryShape.setGeometryPath, e a apresentação é salva no formato PPTX.
import com.aspose.slides.*;
import android.graphics.PointF;
float shapeX = 20f;
float shapeY = 20f;
float shapeWidth = 300f;
float shapeHeight = 200f;
float leftTopSize = 50f;
float rightTopSize = 20f;
float rightBottomSize = 40f;
float leftBottomSize = 10f;
Presentation presentation = new Presentation();
try {
ISlide slide = presentation.getSlides().get_Item(0);
IAutoShape shape = slide.getShapes().addAutoShape(ShapeType.Custom, shapeX, shapeY, shapeWidth, shapeHeight);
PointF topLeft = new PointF(leftTopSize, 0);
PointF topRight = new PointF(shapeWidth - rightTopSize, 0);
PointF rightBottom = new PointF(shapeWidth, shapeHeight - rightBottomSize);
PointF bottomLeft = new PointF(leftBottomSize, shapeHeight);
PointF leftTop = new PointF(0, leftTopSize);
GeometryPath geometryPath = new GeometryPath();
geometryPath.moveTo(topLeft);
geometryPath.lineTo(topRight);
geometryPath.arcTo(rightTopSize, rightTopSize, 180, -90);
geometryPath.lineTo(rightBottom);
geometryPath.arcTo(rightBottomSize, rightBottomSize, -90, -90);
geometryPath.lineTo(bottomLeft);
geometryPath.arcTo(leftBottomSize, leftBottomSize, 0, -90);
geometryPath.lineTo(leftTop);
geometryPath.arcTo(leftTopSize, leftTopSize, 90, -90);
geometryPath.closeFigure();
shape.setGeometryPath(geometryPath);
presentation.save("output.pptx", SaveFormat.Pptx);
} finally {
presentation.dispose();
}
Descobrir se a Geometria de uma Forma está Fechada
O ajudante a seguir verifica se cada caminho de geometria não vazio termina com um segmento de fechamento. Ele lê IGeometryPath.getPathData e compara o comando do segmento final obtido por IPathSegment.getPathCommand com PathCommandType.Close. Retorna false quando não há caminhos não vazios. Essa verificação analisa o comando final de cada caminho; não inspeciona cada sub‑figura dentro de um caminho. O exemplo imprime true para um retângulo.
import com.aspose.slides.*;
class GeometryInspector {
boolean isGeometryClosed(IGeometryShape geometryShape) {
boolean hasNonemptyPath = false;
for (IGeometryPath geometryPath : geometryShape.getGeometryPaths()) {
IPathSegment[] segments = geometryPath.getPathData();
if (segments.length == 0) {
continue;
}
hasNonemptyPath = true;
IPathSegment lastSegment = segments[segments.length - 1];
if (lastSegment.getPathCommand() != PathCommandType.Close) {
return false;
}
}
return hasNonemptyPath;
}
}
Presentation presentation = new Presentation();
try {
ISlide slide = presentation.getSlides().get_Item(0);
IAutoShape shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 100, 100, 200, 100);
GeometryInspector inspector = new GeometryInspector();
boolean closed = inspector.isGeometryClosed(shape);
System.out.println(closed);
} finally {
presentation.dispose();
}
Extrair e Inspecionar Elementos de Forma
Use IGeometryShape.createShapeElements para inspecionar uma forma existente como elementos contendo pontos de caminho e tipos de ponto. Converta cada IShapeElement retornado para ShapeElement a fim de obter os arrays de pontos e tipos por meio dos métodos getPathPoints e getPathTypes . Essa representação é útil para análise de contorno ou para passar a geometria a ferramentas de desenho personalizadas.
O exemplo abre input.pptx, localiza a primeira forma de geometria diretamente no primeiro slide e imprime seus segmentos de caminho. Use uma apresentação que contenha uma forma com segmentos retos e curvos para observar ambos os tipos de saída. Ele não pesquisa dentro de grupos.
import com.aspose.slides.*;
import android.graphics.PointF;
Presentation presentation = new Presentation("input.pptx");
try {
ISlide slide = presentation.getSlides().get_Item(0);
IGeometryShape shape = null;
for (IShape candidate : slide.getShapes()) {
if (candidate instanceof IGeometryShape) {
shape = (IGeometryShape) candidate;
break;
}
}
if (shape == null) {
System.out.println("No geometry shape found on the first slide.");
} else {
for (IShapeElement element : shape.createShapeElements()) {
ShapeElement shapeElement = (ShapeElement) element;
PointF[] points = shapeElement.getPathPoints();
byte[] types = shapeElement.getPathTypes();
System.out.println("Shape element:");
for (int i = 0; i < points.length; i++) {
int pointType = types[i] & 0x07; // Manter o tipo de segmento, excluindo bandeiras.
switch (pointType) {
case 0:
System.out.println("Start figure at " + points[i]);
break;
case 1:
System.out.println("Line to " + points[i]);
break;
case 3:
System.out.println("Cubic Bezier: controls " + points[i] + ", " + points[i + 1] + "; end " + points[i + 2]);
i += 2; // Consume both control points and the endpoint.
break;
}
if ((types[i] & 0x80) != 0) {
System.out.println("Close subpath back to its starting point.");
}
}
}
}
} finally {
presentation.dispose();
}
Os arrays correspondem por índice: points[i] é um ponto e types[i] descreve seu papel. O tipo 0 inicia uma figura, e o tipo 1 desenha uma linha do ponto anterior ao ponto atual. Um segmento Bézier cúbico começa no ponto final anterior e usa três entradas consecutivas de tipo 3: dois pontos de controle seguidos do novo ponto final. O loop consome essas três entradas em conjunto e verifica o ponto final para fechamento.
Os tipos de ponto também contêm bandeiras. Mascarar com 0x07 identifica o tipo de segmento, e testar 0x80 separadamente detecta um subcaminho fechado. Por exemplo, 129 (0x81) significa um ponto final de linha que fecha um subcaminho, e 131 (0x83) significa um ponto final de Bézier que fecha um subcaminho. O Java armazena essas bandeiras em bytes assinados; a máscara preserva os valores de bits pretendidos. Comparar o valor bruto apenas com 1 ou 3 perderia esses casos. Outras bandeiras, como traço (0x10) e marcador (0x20), não alteram o tipo base do segmento.
Coordenadas e transformações. Os pontos são medidos em pontos (1/72 polegada), com X aumentando para a direita e Y aumentando para baixo. Para uma forma não agrupada, as coordenadas extraídas já incluem a posição retornada por getX e getY e refletem sua largura e altura atuais. Por exemplo, um retângulo não rotacionado em (100, 200) com tamanho 120 × 80 tem limites de contorno (100, 200)–(220, 280). Não adicione a posição da forma novamente. Subtraia seu X e Y para obter coordenadas relativas ao seu quadro não rotacionado.
Os pontos extraídos não aplicam a rotação da forma, retornada por getRotation, nem as inversões horizontal e vertical. Para reproduzir o contorno mostrado, aplique essas transformações em torno do centro da forma. Para formas agrupadas, também considere o mapeamento de coordenadas e transformações do grupo; não presuma que os pontos extraídos sejam as coordenadas finais renderizadas no slide nem aplique uma translação ou escala duas vezes se já estiver refletida no quadro filho.
Inspeção versus edição. Os arrays extraídos descrevem o contorno; alterá‑los não atualiza a forma original. Use essa abordagem quando sua análise ou código de desenho precisar de arrays de ponto/tipo. Use getGeometryPaths quando precisar dos comandos de geometria no sistema de coordenadas local da forma ou quiser editar sua geometria. Aplique caminhos editados através de setGeometryPath ou setGeometryPaths.
FAQ
O que acontecerá com o preenchimento e o contorno após substituir a geometria?
O estilo permanece na forma; apenas o contorno muda. O preenchimento e o contorno são aplicados automaticamente à nova geometria.
Como rotacionar corretamente uma forma personalizada junto com sua geometria?
Use o método setRotation da forma; a geometria gira com a forma porque está vinculada ao seu próprio sistema de coordenadas.
Posso converter uma forma personalizada em imagem para “travar” o resultado?
Sim. Exporte a área da slide requerida ou a própria shape para um formato raster; isso simplifica trabalhos posteriores com geometrias complexas.