Metodo IXpsOMGeometryFigure::SetSegments (xpsobjectmodel.h)
Imposta le informazioni sui segmenti e i punti dati per i segmenti nella figura.
Sintassi
HRESULT SetSegments(
[in] UINT32 segmentCount,
[in] UINT32 segmentDataCount,
[in] const XPS_SEGMENT_TYPE *segmentTypes,
[in] const FLOAT *segmentData,
[in] const BOOL *segmentStrokes
);
Parametri
[in] segmentCount
Numero di segmenti.
Questo valore è anche il numero di elementi nelle matrici a cui fa riferimento segmentTypes e segmentStrokes.
[in] segmentDataCount
Numero di punti dati del segmento.
Questo valore è anche il numero di elementi nella matrice a cui fa riferimento segmentData.
[in] segmentTypes
Matrice di variabili XPS_SEGMENT_TYPE . Il valore di segmentCount specifica il numero di elementi in questa matrice.
[in] segmentData
Matrice di valori di dati di segmento. Il valore di segmentDataCount specifica il numero di elementi in questa matrice.
[in] segmentStrokes
Matrice di valori del tratto segmento. Il valore di segmentCount specifica il numero di elementi in questa matrice.
Valore restituito
Il metodo restituisce un valore HRESULT. I valori possibili includono, ma non solo, quelli nella tabella che segue. Per informazioni sui valori restituiti dell'API documento XPS non elencati in questa tabella, vedere Errori del documento XPS.
| Codice restituito | Descrizione |
|---|---|
|
Il metodo è riuscito. |
|
segmentTypes contiene un valore di tipo non riconosciuto.
In alternativa, il numero di voci nella matrice segmentData è maggiore del numero di voci nella matrice segmentTypes . |
|
segmentTypes, segmentData o segmentStrokes è NULL. |
|
segmentData contiene un valore FLOAT infinito o non un numero (NAN). |
|
La matrice passata in segmentData contiene meno voci rispetto alla matrice passata in segmentTypes. |
|
Una voce nella matrice passata in segmentData contiene un valore negativo, ma deve contenere un valore non negativo. |
Commenti
Un segmento geometry viene descritto dal punto iniziale, dal tipo di segmento e dai parametri aggiuntivi i cui valori sono determinati dal tipo di segmento. Le coordinate per il punto iniziale del primo segmento sono una proprietà della figura geometrica e vengono impostate chiamando SetStartPoint. Il punto iniziale di ogni segmento successivo è il punto finale del segmento precedente.
Il numero di valori di dati che definiscono un segmento di linea dipende dal tipo di segmento. La tabella seguente descrive il set specifico di valori di dati necessari che devono essere utilizzati per ogni tipo di segmento. I valori nella matrice di dati del segmento passati nel parametro segmentData devono corrispondere ai valori XPS_SEGMENT_TYPE nella matrice passata nel parametro segmentTypes . Ad esempio, se il primo segmento di linea ha un valore di tipo segmento di XPS_SEGMENT_TYPE_LINE, i primi due valori di dati nella matrice segmentData saranno le coordinate x e y del punto finale del segmento; se il segmento successivo ha un valore di tipo segmento pari a XPS_SEGMENT_TYPE_BEZIER, i sei valori successivi nella matrice segmentData descrivono le caratteristiche di tale segmento; e così via per ogni segmento di linea nella figura geometrica.
| Tipo di segmento | Valori dei dati obbligatori |
|---|---|
XPS_SEGMENT_TYPE_LINE 
|
Due valori di dati:
|
XPS_SEGMENT_TYPE_ARC_LARGE_CLOCKWISE 
|
Cinque valori di dati:
|
XPS_SEGMENT_TYPE_ARC_SMALL_CLOCKWISE 
|
Cinque valori di dati:
|
XPS_SEGMENT_TYPE_ARC_LARGE_COUNTERCLOCKWISE 
|
Cinque valori di dati:
|
XPS_SEGMENT_TYPE_ARC_SMALL_COUNTERCLOCKWISE 
|
Cinque valori di dati:
|
XPS_SEGMENT_TYPE_BEZIER 
|
Sei valori di dati:
|
XPS_SEGMENT_TYPE_QUADRATIC_BEZIER 
|
Quattro valori di dati:
|
Per ottenere i tipi di segmento nella figura, chiamare GetSegmentTypes.
Gli esempi di codice seguenti illustrano un modo per creare e popolare i buffer richiesti da SetSegments.
Nel primo esempio di codice, il metodo AddSegmentDataToArrays accetta i punti dati che descrivono un singolo segmento e li archivia nei tre buffer di dati diversi richiesti dal metodo SetSegments . I buffer di dati passati come argomenti a AddSegmentDataToArrays vengono gestiti dal metodo chiamante, come illustrato nell'esempio di codice che segue AddSegmentDataToArrays.
HRESULT
AddSegmentDataToArrays(
XPS_SEGMENT_TYPE segmentType,
BOOL segmentStroke,
FLOAT *segmentPoints,
UINT32 *segmentsAvailable,
UINT32 *segmentPointsAvailable,
XPS_SEGMENT_TYPE **segmentTypeBuffer,
BOOL **segmentStrokeBuffer,
FLOAT **segmentPointBuffer
)
/*
Description:
Populates the buffers required by IXpsOMGeometryFigure::SetSegmentData
using data and buffers provided by the calling method.
Parameters:
segmentType
IN: XPS_SEGMENT_TYPE value that specifies the segment type for
the current segment.
segmentStroke
IN: BOOL value that specifies whether the current segment
is stroked.
*segmentPoints
IN: pointer to an array of FLOAT values that specify the
segment's data points. The number of values in the array
depend on the value of the segmentType parameter.
*segmentsAvailable
IN: the number of values that remain unused in the
segmentTypeBuffer and the segmentStrokeBuffer.
This value must be >= 1 when calling the method.
OUT: the number of values that remain unused in the
segmentTypeBuffer and the segmentStrokeBuffer after
segmentType and segmentStroke have been added. If the
method was successful, the returned value is one less
than the value passed in to the method.
*segmentPointsAvailable
IN: the number of values that remain unused in the
segmentPointBuffer. This value must be greater-than or equal
to the number of points required by the segmentType value.
OUT: the number of values that remain unused in the
segmentPointBuffer after the segmentPoints have been added.
The returned value depends on the segmentType value.
**segmentTypeBuffer
IN: the first free element in the buffer that receives the segment
type values.
OUT: the first free element in the buffer that receives the segment
type values. If the method is successful, this will be the element
after the element pointed to by this value before the method
was called.
**segmentStrokeBuffer
IN: the first free element in the buffer that receives the segment
stroke values.
OUT: the first free element in the buffer that receives the segment
stroke values. If the method is successful, this will be the element
after the element pointed to by this value before the method
was called.
**segmentPointBuffer
IN: the first free element in the buffer that receives the segment
point values.
OUT: the first free element in the buffer that receives the segment
point values. If the method is successful, the element referenced
by this value will depend on the segment type.
Remarks.
1) the buffers and values passed into this method are managed by
the calling method.
2) if the value returned in segmentsAvailable is 0, segmentTypeBuffer
and segmentStrokeBuffer point to invalid memory.
3) if the value returned in segmentPointsAvailable is 0, segmentPointBuffer
point to invalid memory.
*/
{
HRESULT hr = S_OK;
// test to see if there is sufficient space in the
// segmentTypeBuffer and the segmentStrokeBuffer before
// proceeding
if (*segmentsAvailable == 0)
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
}
if (SUCCEEDED(hr))
{
// process the data based on the segment type
switch (segmentType)
{
case XPS_SEGMENT_TYPE_ARC_LARGE_CLOCKWISE:
case XPS_SEGMENT_TYPE_ARC_LARGE_COUNTERCLOCKWISE:
case XPS_SEGMENT_TYPE_ARC_SMALL_CLOCKWISE:
case XPS_SEGMENT_TYPE_ARC_SMALL_COUNTERCLOCKWISE:
if (*segmentPointsAvailable >= 5)
{
// 5 data points
*(*segmentPointBuffer)++ = *segmentPoints++; //<arc end point (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<arc end point (y)
*(*segmentPointBuffer)++ = *segmentPoints++; //<arc radius (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<arc radius (y)
*(*segmentPointBuffer)++ = *segmentPoints++; //<arc angle
*segmentPointsAvailable -= 5;
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
}
break;
case XPS_SEGMENT_TYPE_BEZIER:
if (*segmentPointsAvailable >= 6)
{
// 6 data points
*(*segmentPointBuffer)++ = *segmentPoints++; //<control point 1 (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<control point 1 (y)
*(*segmentPointBuffer)++ = *segmentPoints++; //<control point 2 (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<control point 2 (y)
*(*segmentPointBuffer)++ = *segmentPoints++; //<end point (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<end point (y)
*segmentPointsAvailable -= 6;
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
}
break;
case XPS_SEGMENT_TYPE_LINE:
if (*segmentPointsAvailable >= 2)
{
// 2 data points
*(*segmentPointBuffer)++ = *segmentPoints++; //<end point (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<end point (y)
*segmentPointsAvailable -= 2;
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
}
break;
case XPS_SEGMENT_TYPE_QUADRATIC_BEZIER:
if (*segmentPointsAvailable >= 4)
{
// 4 data points
*(*segmentPointBuffer)++ = *segmentPoints++; //<control point 2 (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<control point 2 (y)
*(*segmentPointBuffer)++ = *segmentPoints++; //<end point (x)
*(*segmentPointBuffer)++ = *segmentPoints++; //<end point (y)
*segmentPointsAvailable -= 4;
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
}
break;
default:
// unrecognized segment type
hr = E_UNEXPECTED;
break;
}
}
if (SUCCEEDED(hr))
{
// Copy segment type and segment stroke values
// to array and decrement number of array values
// that remain unused.
//
// The space available for these operations was
// tested at the beginning of the method.
*(*segmentTypeBuffer)++ = segmentType;
*(*segmentStrokeBuffer)++ = segmentStroke;
*segmentsAvailable--;
}
return hr;
}
In questo esempio di codice UpdateSegmentData crea i buffer di dati richiesti dal metodo SetSegments e chiama il metodo AddSegmentDataToArrays dall'esempio di codice precedente per popolarli con i dati del segmento. Dopo aver popolato i buffer, SetSegments viene chiamato per aggiungere questi dati alla figura geometry.
HRESULT
UpdateSegmentData (
IXpsOMGeometryFigure *geometryFigure,
UINT32 segmentCount,
UINT32 segmentDataCount
)
/*
Note that this method is not complete and only includes
the code necessary to show how the SetSegments call is used.
In this sample, the geometryFigure, segmentCount, and
segmentDataCount values are assumed to have been initialized
outside of this example.
*/
{
HRESULT hr = S_OK;
XPS_SEGMENT_TYPE segmentType = (XPS_SEGMENT_TYPE)0;
BOOL segmentStroke = FALSE;
FLOAT segmentPoints = 0;
UINT32 segmentsAvailable = 0;
UINT32 segmentPointsAvailable = 0;
// these buffers are sized and allocated based on
// the segment data to store.
XPS_SEGMENT_TYPE *segmentTypeBuffer = NULL;
BOOL *segmentStrokeBuffer = NULL;
FLOAT *segmentPointBuffer = NULL;
XPS_SEGMENT_TYPE *nextSegmentTypeValue = NULL;
BOOL *nextSegmentStrokeValue = NULL;
FLOAT *nextSegmentPointValue = NULL;
// segment data is created outside of this example
// allocate buffers as required using information
// from segment data. This can be dynamic or static
// depending on how the segment information is managed.
// This example assumes that the segment information
// does not change during this method.
// initialize "next" pointers to point to the first
// element in each array.
nextSegmentTypeValue = segmentTypeBuffer;
nextSegmentStrokeValue = segmentStrokeBuffer;
nextSegmentPointValue = segmentPointBuffer;
// for each segment in the figure, add the
// segment data to the buffers
hr = AddSegmentDataToArrays(
segmentType,
segmentStroke,
&segmentPoints,
&segmentsAvailable,
&segmentPointsAvailable,
&nextSegmentTypeValue,
&nextSegmentStrokeValue,
&nextSegmentPointValue);
if (SUCCEEDED(hr))
{
// set segment data
hr = geometryFigure->SetSegments (
segmentCount,
segmentDataCount,
segmentTypeBuffer,
segmentPointBuffer,
segmentStrokeBuffer);
}
// clean up buffers
return hr;
}
Requisiti
| Requisito | Valore |
|---|---|
| Client minimo supportato | Windows 7, Windows Vista con SP2 e Aggiornamento della piattaforma per Windows Vista [app desktop | App UWP] |
| Server minimo supportato | Windows Server 2008 R2, Windows Server 2008 con SP2 e Platform Update per Windows Server 2008 [app desktop | App UWP] |
| Piattaforma di destinazione | Windows |
| Intestazione | xpsobjectmodel.h |