/// <summary><para> /// Call this function after <see cref="GetBorderCounts"/> to export the corresponding border to your own /// <see cref="Outline"/> structure. /// </para><para> /// Note that this function appends the border points and contours to your outline, but does not try to resize /// its arrays. /// </para></summary> /// <remarks><para> /// Always call this function after <see cref="GetBorderCounts"/> to get sure that there is enough room in your /// <see cref="Outline"/> object to receive all new data. /// </para><para> /// When an outline, or a sub-path, is ‘closed’, the stroker generates two independent ‘border’ outlines, named /// ‘left’ and ‘right’. /// </para><para> /// When the outline, or a sub-path, is ‘opened’, the stroker merges the ‘border’ outlines with caps. The /// ‘left’ border receives all points, while the ‘right’ border becomes empty. /// </para><para> /// Use the function <see cref="Export"/> instead if you want to retrieve all borders at once. /// </para></remarks> /// <param name="border">The border index.</param> /// <param name="outline">The target outline handle.</param> public void ExportBorder(StrokerBorder border, Outline outline) { if (disposed) throw new ObjectDisposedException("Stroker", "Cannot access a disposed object."); if (outline == null) throw new ArgumentNullException("outline"); FT.FT_Stroker_ExportBorder(Reference, border, outline.Reference); }
/// <summary> /// A convenience function used to parse a whole outline with the stroker. The resulting outline(s) can be /// retrieved later by functions like <see cref="GetCounts"/> and <see cref="Export"/>. /// </summary> /// <remarks><para> /// If ‘opened’ is 0 (the default), the outline is treated as a closed path, and the stroker generates two /// distinct ‘border’ outlines. /// </para><para> /// If ‘opened’ is 1, the outline is processed as an open path, and the stroker generates a single ‘stroke’ /// outline. /// </para><para> /// This function calls <see cref="Rewind"/> automatically. /// </para></remarks> /// <param name="outline">The source outline.</param> /// <param name="opened"> /// A boolean. If 1, the outline is treated as an open path instead of a closed one. /// </param> public void ParseOutline(Outline outline, bool opened) { if (disposed) throw new ObjectDisposedException("Stroker", "Cannot access a disposed object."); if (outline == null) throw new ArgumentNullException("outline"); Error err = FT.FT_Stroker_ParseOutline(Reference, outline.Reference, opened); if (err != Error.Ok) throw new FreeTypeException(err); }
/// <summary> /// Copy an outline into another one. Both objects must have the same sizes (number of points & number of /// contours) when this function is called. /// </summary> /// <param name="target">A handle to the target outline.</param> public void Copy(Outline target) { if (disposed) throw new ObjectDisposedException("Outline", "Cannot access a disposed object."); if (target == null) throw new ArgumentNullException("target"); IntPtr targetRef = target.Reference; Error err = FT.FT_Outline_Copy(reference, ref targetRef); target.Reference = reference; if (err != Error.Ok) throw new FreeTypeException(err); }
internal void RemoveChildOutline(Outline child) { childOutlines.Remove(child); }
internal void AddChildOutline(Outline child) { childOutlines.Add(child); }