include/cinder/cocoa/CinderCocoa.h

Go to the documentation of this file.

/*
 Copyright (c) 2010, The Barbarian Group
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification, are permitted provided that
 the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and
    the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
    the following disclaimer in the documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include "cinder/Cinder.h"
#include "cinder/Surface.h"
#include "cinder/Shape2d.h"
#include "cinder/Color.h"
#include "cinder/Buffer.h"
#include "cinder/ImageIo.h"
namespace cinder {
    class Url;
    class Font;
}

#if defined( CINDER_COCOA_TOUCH )
    #include <CoreGraphics/CoreGraphics.h>
#else
    #include <ApplicationServices/ApplicationServices.h>
#endif
#include <CoreFoundation/CoreFoundation.h>
#if defined( __OBJC__ )
    @class NSBitmapImageRep;
    @class NSString;
    @class NSData;
#else
    class NSBitmapImageRep;
    class NSString;
    class NSData;   
#endif

namespace cinder { namespace cocoa {

typedef std::shared_ptr<struct __CFString> SafeCfString;

class SafeNsString {
  public:
    SafeNsString() {}
    SafeNsString( NSString *str );
    SafeNsString( const std::string &str );
    
    operator NSString* const() { if( mPtr ) return mPtr.get(); else return 0; }
    operator std::string() const;
    
  private:
    static void safeRelease( NSString *ptr );
    
    std::shared_ptr<NSString>   mPtr;
};

class SafeNsData {
  public:
    SafeNsData() {}
    SafeNsData( const Buffer &buffer );
    
    operator NSData* const() { if( mPtr ) return mPtr.get(); else return 0; }
    
  private:
    static void safeRelease( const NSData *ptr );
    
    std::shared_ptr<NSData> mPtr;
    const Buffer            mBuffer;
};

class SafeNsAutoreleasePool {
  public:
    SafeNsAutoreleasePool();
    ~SafeNsAutoreleasePool();
    
  private:
    void            *mPool;
};

void safeCfRelease( const CFTypeRef cfRef );

void safeCocoaRelease( void *nsObject );

CGContextRef createCgBitmapContext( const Surface8u &surface );

CGContextRef getWindowContext();

#if defined( CINDER_MAC )

Surface8u convertNsBitmapDataRep( const NSBitmapImageRep *rep, bool assumeOwnership = false );
#endif

std::string convertCfString( CFStringRef str );
CFStringRef createCfString( const std::string &str );
SafeCfString createSafeCfString( const std::string &str );
std::string convertNsString( NSString *str );
CFURLRef createCfUrl( const cinder::Url &url );

CFAttributedStringRef createCfAttributedString( const std::string &str, const cinder::Font &font, const ColorA &color );
CFAttributedStringRef createCfAttributedString( const std::string &str, const cinder::Font &font, const ColorA &color, bool ligate );

CGColorRef createCgColor( const Color &color );
CGColorRef createCgColor( const ColorA &color );

CGRect createCgRect( const Area &area );
Area CgRectToArea( const CGRect &rect );

inline CGSize createCgSize( const Vec2i &s ) { CGSize result; result.width = s.x; result.height = s.y; return result; }
inline CGSize createCgSize( const Vec2f &s ) { CGSize result; result.width = s.x; result.height = s.y; return result; }

void convertCgPath( CGPathRef cgPath, Shape2d *resultShape, bool flipVertical = true );

#if defined( CINDER_MAC )

int getCvPixelFormatTypeFromSurfaceChannelOrder( const SurfaceChannelOrder &sco );
#endif

CFDataRef createCfDataRef( const cinder::Buffer &buffer );


typedef std::shared_ptr<class ImageSourceCgImage> ImageSourceCgImageRef;

class ImageSourceCgImage : public ImageSource {
  public:
    static ImageSourceCgImageRef    createRef( ::CGImageRef imageRef, ImageSource::Options options = ImageSource::Options() );
    virtual ~ImageSourceCgImage() {}

    virtual void    load( ImageTargetRef target );

  protected:
    ImageSourceCgImage( ::CGImageRef imageRef, ImageSource::Options options );

    bool                        mIsIndexed, mIs16BitPacked;
    Color8u                     mColorTable[256];
    std::shared_ptr<CGImage>    mImageRef;

    uint16_t                    m16BitPackedRedOffset, m16BitPackedGreenOffset, m16BitPackedBlueOffset;
};

ImageSourceCgImageRef createImageSource( ::CGImageRef imageRef, ImageSource::Options = ImageSource::Options() );


typedef std::shared_ptr<class ImageTargetCgImage> ImageTargetCgImageRef;

class ImageTargetCgImage : public ImageTarget {
  public:
    static ImageTargetCgImageRef createRef( ImageSourceRef imageSource, ImageTarget::Options options );
    ~ImageTargetCgImage();

    virtual void*   getRowPointer( int32_t row );
    virtual void    finalize();

    ::CGImageRef    getCgImage() const { return mImageRef; }

  protected:
    ImageTargetCgImage( ImageSourceRef imageSource, ImageTarget::Options options );

    ::CGImageRef        mImageRef;
    size_t              mBitsPerComponent, mBitsPerPixel, mRowBytes;
    ::CGBitmapInfo      mBitmapInfo;
    ::CFMutableDataRef  mDataRef;
    uint8_t             *mDataPtr;
};

::CGImageRef createCgImage( ImageSourceRef imageSource, ImageTarget::Options = ImageTarget::Options() );


} } // namespace cinder::cocoa

namespace cinder {

class SurfaceConstraintsCgBitmapContext : public cinder::SurfaceConstraints {
 public:
    virtual SurfaceChannelOrder getChannelOrder( bool alpha ) const;
    virtual int32_t             getRowBytes( int requestedWidth, const SurfaceChannelOrder &sco, int elementSize ) const;
};

} // namespace cinder