Addingn DrawKit 1.0.1.

Author: grahammiln

DKDrawKit.framework/DKDrawKit

@@ -0,0 +1 @@
+Versions/Current/DKDrawKit

DKDrawKit.framework/Headers

@@ -0,0 +1 @@
+Versions/Current/Headers

DKDrawKit.framework/Resources

@@ -0,0 +1 @@
+Versions/Current/Resources

DKDrawKit.framework/Versions/A/DKDrawKit

@@ -0,0 +1,40 @@
+/*
+ *  CurveFit.h
+///  DrawKit ©2005-2008 Apptree.net
+ *
+ *  Created by graham on 05/11/2006.
+ *  Copyright 2006 Apptree.net. All rights reserved.
+ *
+ */
+
+// utils:
+
+#ifdef qUseCurveFit
+
+#import <Cocoa/Cocoa.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+// curve fit vector paths using bezier curve fitting:
+
+NSBezierPath*		curveFitPath(NSBezierPath* inPath, float epsilon);
+NSBezierPath*		smartCurveFitPath( NSBezierPath* inPath, float epsilon, float cornerAngleThreshold );
+
+#ifdef __cplusplus
+}
+#endif
+
+// curve fit vector path using poTrace smoothing algorithm:
+
+
+#ifndef SIGN
+#define SIGN(x)		((x) > 0? 1 : (x) < 0? -1 : 0)
+#endif
+
+
+#define kDKDefaultCornerThreshold		(pi / 6)
+
+#endif /* defined(qUseCurveFit) */

DKDrawKit.framework/Versions/A/Headers/CurveFit.h

@@ -0,0 +1,72 @@
+/**
+ @author Graham Cox, Apptree.net
+ @author Graham Miln, miln.eu
+ @author Contributions from the community
+ @date 2005-2014
+ @copyright This software is released subject to licensing conditions as detailed in DRAWKIT-LICENSING.TXT, which must accompany this source file.
+ */
+
+#import "DKDrawablePath.h"
+
+// shape types this class supports:
+
+typedef enum {
+    kDKArcPathOpenArc = 0,
+    kDKArcPathWedge,
+    kDKArcPathCircle
+} DKArcPathType;
+
+// the class:
+
+@interface DKArcPath : DKDrawablePath <NSCopying, NSCoding> {
+@private
+    CGFloat mRadius;
+    CGFloat mStartAngle;
+    CGFloat mEndAngle;
+    NSPoint mCentre;
+    DKArcPathType mArcType;
+}
+
+- (void)setRadius:(CGFloat)rad;
+- (CGFloat)radius;
+
+- (void)setStartAngle:(CGFloat)sa;
+- (CGFloat)startAngle;
+
+- (void)setEndAngle:(CGFloat)ea;
+- (CGFloat)endAngle;
+
+/** @brief Sets the arc type, which affects the path geometry
+ @param arcType the required type
+ */
+- (void)setArcType:(DKArcPathType)arcType;
+
+/** @brief Returns the arc type, which affects the path geometry
+ @return the current arc type
+ */
+- (DKArcPathType)arcType;
+
+- (IBAction)convertToPath:(id)sender;
+
+@end
+
+// partcodes this class defines - note that the implicit partcodes used by DKDrawablePath are not used by this class,
+// so we don't need to ensure these are out of range. The numbers here are entirely arbitrary, but the code does assume
+// they are consecutive, continuous, and ordered thus:
+
+enum {
+    kDKArcPathRadiusPart = 2,
+    kDKArcPathStartAnglePart,
+    kDKArcPathEndAnglePart,
+    kDKArcPathRotationKnobPart,
+    kDKArcPathCentrePointPart,
+};
+
+// the simple creation mode can be set (rather than, say, kDKPathCreateModeArcSegment) to create arcs in a one-step process
+// which simply drags out the radius of an arc 45 degrees centred on the horizontal axis. The arc is editable in
+// exactly the same way afterwards so there is no functionality lost doing it this way. It might be found to be easier to use
+// than the 2-stage arc creation process.
+
+enum {
+    kDKArcSimpleCreationMode = 7
+};

DKDrawKit.framework/Versions/A/Headers/DKArcPath.h

@@ -0,0 +1,152 @@
+/**
+ @author Graham Cox, Apptree.net
+ @author Graham Miln, miln.eu
+ @author Contributions from the community
+ @date 2005-2014
+ @copyright This software is released subject to licensing conditions as detailed in DRAWKIT-LICENSING.TXT, which must accompany this source file.
+ */
+
+#import "DKStroke.h"
+
+// arrow head kinds - each end can be specified independently:
+
+typedef enum {
+    kDKArrowHeadNone = 0,
+    kDKArrowHeadStandard = 1,
+    kDKArrowHeadInflected = 2,
+    kDKArrowHeadRound = 3,
+    kDKArrowHeadSingleFeather = 4,
+    kDKArrowHeadDoubleFeather = 5,
+    kDKArrowHeadTripleFeather = 6,
+    kDKArrowHeadDimensionLine = 7,
+    kDKArrowHeadDimensionLineAndBar = 8,
+    kDKArrowHeadSquare = 9,
+    kDKArrowHeadDiamond = 10
+} DKArrowHeadKind;
+
+// positioning of dimension label, or none:
+
+typedef enum {
+    kDKDimensionNone = 0,
+    kDKDimensionPlaceAboveLine = 1,
+    kDKDimensionPlaceInLine = 2,
+    kDKDimensionPlaceBelowLine = 3
+} DKDimensioningLineOptions;
+
+// dimension kind - sets additional embellishments on the dimension text:
+
+typedef enum {
+    kDKDimensionLinear = 0,
+    kDKDimensionDiameter = 1,
+    kDKDimensionRadius = 2,
+    kDKDimensionAngle = 3
+} DKDimensionTextKind;
+
+// tolerance options:
+
+typedef enum {
+    kDKDimensionToleranceNotShown = 0,
+    kDKDimensionToleranceShown = 1
+} DKDimensionToleranceOption;
+
+// the class:
+
+/** @brief DKArrowStroke is a rasterizer that implements arrowheads on the ends of paths.
+
+ DKArrowStroke is a rasterizer that implements arrowheads on the ends of paths. The heads are drawn by filling the
+ arrowhead using the same colour as the stroke, thus seamlessly blending the head into the path. Where multiple
+ strokes are used, the resulting effect should be correct when angles are kept the same and lengths are calculated
+ from the stroke width.
+*/
+@interface DKArrowStroke : DKStroke <NSCoding, NSCopying> {
+@private
+    DKArrowHeadKind mArrowHeadAtStart;
+    DKArrowHeadKind mArrowHeadAtEnd;
+    CGFloat m_arrowLength;
+    CGFloat m_arrowWidth;
+    DKDimensioningLineOptions mDimensionOptions;
+    NSNumberFormatter* m_dims_formatter;
+    NSColor* m_outlineColour;
+    CGFloat m_outlineWidth;
+    DKDimensionTextKind mDimTextKind;
+    DKDimensionToleranceOption mDimToleranceOptions;
+}
+
++ (void)setDimensioningLineTextAttributes:(NSDictionary*)attrs;
++ (NSDictionary*)dimensioningLineTextAttributes;
++ (DKArrowStroke*)standardDimensioningLine;
++ (NSNumberFormatter*)defaultDimensionLineFormatter;
+
+// head kind at each end
+
+- (void)setArrowHeadAtStart:(DKArrowHeadKind)kind;
+- (void)setArrowHeadAtEnd:(DKArrowHeadKind)kind;
+- (DKArrowHeadKind)arrowHeadAtStart;
+- (DKArrowHeadKind)arrowHeadAtEnd;
+
+// head widths and lengths (some head kinds may set these also)
+
+- (void)setArrowHeadWidth:(CGFloat)width;
+- (CGFloat)arrowHeadWidth;
+- (void)setArrowHeadLength:(CGFloat)length;
+- (CGFloat)arrowHeadLength;
+
+- (void)standardArrowForStrokeWidth:(CGFloat)sw;
+
+#ifdef DRAWKIT_DEPRECATED
+- (void)setOutlineColour:(NSColor*)colour width:(CGFloat)width;
+#endif
+
+- (void)setOutlineColour:(NSColor*)colour;
+- (NSColor*)outlineColour;
+- (void)setOutlineWidth:(CGFloat)width;
+- (CGFloat)outlineWidth;
+
+- (NSImage*)arrowSwatchImageWithSize:(NSSize)size strokeWidth:(CGFloat)width;
+- (NSImage*)standardArrowSwatchImage;
+
+- (NSBezierPath*)arrowPathFromOriginalPath:(NSBezierPath*)inPath fromObject:(id)obj;
+
+// dimensioning lines:
+
+- (void)setFormatter:(NSNumberFormatter*)fmt;
+- (NSNumberFormatter*)formatter;
+- (void)setFormat:(NSString*)format;
+
+- (void)setDimensioningLineOptions:(DKDimensioningLineOptions)dimOps;
+- (DKDimensioningLineOptions)dimensioningLineOptions;
+
+- (NSAttributedString*)dimensionTextForObject:(id)obj;
+- (CGFloat)widthOfDimensionTextForObject:(id)obj;
+- (NSString*)toleranceTextForObject:(id)object;
+
+- (void)setDimensionTextKind:(DKDimensionTextKind)kind;
+- (DKDimensionTextKind)dimensionTextKind;
+
+- (void)setDimensionToleranceOption:(DKDimensionToleranceOption)option;
+- (DKDimensionToleranceOption)dimensionToleranceOption;
+
+- (void)setTextAttributes:(NSDictionary*)dict;
+- (NSDictionary*)textAttributes;
+- (void)setFont:(NSFont*)font;
+- (NSFont*)font;
+
+@end
+
+/** @brief informal protocol for requesting dimension information from an object.
+
+ If it does not respond, the rasterizer infers the values from the path length and its internal values.
+ */
+@interface NSObject (DKArrowSrokeDimensioning)
+
+- (NSDictionary*)dimensionValuesForArrowStroke:(DKArrowStroke*)arrowStroke;
+
+@end
+
+#define kDKStandardArrowSwatchImageSize (NSMakeSize(80.0, 9.0))
+#define kDKStandardArrowSwatchStrokeWidth 3.0
+
+extern NSString* kDKPositiveToleranceKey;
+extern NSString* kDKNegativeToleranceKey;
+extern NSString* kDKDimensionValueKey;
+extern NSString* kDKDimensionUnitsKey;

DKDrawKit.framework/Versions/A/Headers/DKArrowStroke.h

@@ -0,0 +1,61 @@
+/**
+ @author Graham Cox, Apptree.net
+ @author Graham Miln, miln.eu
+ @author Contributions from the community
+ @date 2005-2014
+ @copyright This software is released subject to licensing conditions as detailed in DRAWKIT-LICENSING.TXT, which must accompany this source file.
+ */
+
+#import <Cocoa/Cocoa.h>
+#import "DKBSPObjectStorage.h"
+
+@class DKBSPDirectTree;
+
+/**
+ This uses a similar algorithm to DKBSPObjectStorage but instead of indexing the objects it stores them directly by retaining them in additional arrays
+ within the BSP tree. This is likely to be faster than the indexing approach though profiling is needed to confirm this.
+ 
+ To facilitate correct z-ordering, each object stores its own Z-position and the objects are sorted on this property when necessary. Objects need to be
+ renumbered when indexes change.
+
+ The trade-off here is that drawing speed should be faster but object insertion, deletion and changing of Z-position may be slower.
+*/
+@interface DKBSPDirectObjectStorage : DKLinearObjectStorage {
+@private
+    DKBSPDirectTree* mTree;
+    NSUInteger mTreeDepth;
+    NSUInteger mLastItemCount;
+    BOOL mAutoRebuild;
+}
+
+- (void)setTreeDepth:(NSUInteger)aDepth;
+- (id)tree;
+- (NSBezierPath*)debugStorageDivisions;
+
+@end
+
+#pragma mark -
+
+/// tree object
+
+@interface DKBSPDirectTree : DKBSPIndexTree {
+@public
+    id<DKStorableObject> mObj;
+    NSMutableArray* mFoundObjects;
+    NSUInteger mObjectCount;
+    NSView* mViewRef;
+    NSRect mRect;
+}
+
+- (void)insertItem:(id<DKStorableObject>)obj withRect:(NSRect)rect;
+- (void)removeItem:(id<DKStorableObject>)obj withRect:(NSRect)rect;
+- (void)removeAllObjects;
+- (NSUInteger)count;
+
+// tree returns mutable results so that they can be sorted in place without needing to be copied
+
+- (NSMutableArray*)objectsIntersectingRects:(const NSRect*)rects count:(NSUInteger)count inView:aView;
+- (NSMutableArray*)objectsIntersectingRect:(NSRect)rect;
+- (NSMutableArray*)objectsIntersectingPoint:(NSPoint)point;
+
+@end