text:
static NSString * const kSoftwareCatalogCellID = @"SoftwareCatalogCell";

@interface SoftwareCatalogVC ()

@property (nonatomic, assign) int tag;

@end

@implementation SoftwareCatalogVC

- (instancetype)initWithTag:(int)tag
{
    self = [super init];
    if (!self) {return nil;}

    _tag = tag;

    self.generateURL = ^NSString * (NSUInteger page) {
        return [NSString stringWithFormat:@"%@%@?tag=%d", OSCAPI_PREFIX, OSCAPI_SOFTWARECATALOG_LIST, tag];;
    };

    __weak typeof(self) weakSelf = self;
    self.tableWillReload = ^(NSUInteger responseObjectsCounts) {
        [weakSelf.lastCell statusFinished];
    };

    self.objClass = [OSCSoftwareCatalog class];

    return self;
}

- (void)viewDidLoad
{
    [super viewDidLoad];

    [self.tableView registerClass:[UITableViewCell class] forCellReuseIdentifier:kSoftwareCatalogCellID];
}

- (NSArray *)parseXML:(ONOXMLDocument *)xml {
    return [[xml.rootElement firstChildWithTag:@"softwareTypes"] childrenWithTag:@"softwareType"];
}

#pragma mark - UITableViewDataSource
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (indexPath.row < self.objects.count) {
        UITableViewCell *cell = [self.tableView dequeueReusableCellWithIdentifier:kSoftwareCatalogCellID forIndexPath:indexPath];
        OSCSoftwareCatalog *softwareCatalog = self.objects[indexPath.row];

        cell.backgroundColor = [UIColor themeColor];
        cell.textLabel.text = softwareCatalog.name;

        return cell;
    } else {
        return self.lastCell;
    }
}

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (indexPath.row < self.objects.count) {
        return 48;
    } else {
        return 60;
    }
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    [tableView deselectRowAtIndexPath:indexPath animated:YES];
    NSInteger row = indexPath.row;

    if (row < self.objects.count) {
        OSCSoftwareCatalog *softwareCatalog = self.objects[indexPath.row];
        if (_tag == 0) {
            SoftwareCatalogVC *softwareCatalogVC = [[SoftwareCatalogVC alloc] initWithTag:softwareCatalog.tag];
            [self.navigationController pushViewController:softwareCatalogVC animated:YES];
        } else {
            SoftwareListVC *softwareListVC = [[SoftwareListVC alloc] initWIthSearchTag:softwareCatalog.tag];
            [self.navigationController pushViewController:softwareListVC animated:YES];
        }
    } else {
        [self fetchMore];
    }
}

@end


text:
<?php
declare(strict_types=1);

namespace Ytake\LaravelCouchbase\Exceptions;

/**
 * Class NotSupportedException.
 *
 * @author Yuuki Takezawa<yuuki.takezawa@comnect.jp.net>
 */
final class NotSupportedException extends \Exception
{
    /**
     * @param string          $message
     * @param int             $code
     * @param \Throwable|null $previous
     */
    public function __construct($message, $code = 0, \Throwable $previous = null)
    {
        parent::__construct("$message method is not supported", $code, $previous);
    }
}

redpajama_set_name: RedPajamaGithub


text:
<?php
$count_attr_default = array(
	'class' => array('comment_count'),
	'id' => 'comment_count_'.$id,
	'data-id' => $id,
);
if (!isset($count_attr)) $count_attr = array();
$count_attr = Util_Toolkit::convert_to_attr($count_attr, $count_attr_default);

$link_attr_default = array(
	'class' => array('link_show_comment'),
	'id' => 'link_show_comment_'.$id,
	'data-id' => $id,
);
if (!isset($link_attr)) $link_attr = array();
$link_attr = Util_Toolkit::convert_to_attr($link_attr, $link_attr_default);
?>
<?php echo icon('comment'); ?> <?php echo html_tag('span', $count_attr, isset($count) ? $count : ''); ?>
<?php if ((Auth::check() || !empty($link_display_absolute)) && empty($link_hide_absolute)): ?>
<?php echo anchor('#', term('form.comment'), false, $link_attr); ?>
<?php endif; ?>


text:
@class ComGoogleCommonCollectBoundTypeEnum;
@class ComGoogleCommonCollectImmutableSortedMultiset_Builder;
@class ComGoogleCommonCollectImmutableSortedSet;
@class IOSObjectArray;
@protocol ComGoogleCommonCollectMultiset_Entry;
@protocol JavaLangComparable;
@protocol JavaLangIterable;
@protocol JavaUtilComparator;
@protocol JavaUtilIterator;

@interface ComGoogleCommonCollectImmutableSortedMultiset : ComGoogleCommonCollectImmutableSortedMultisetFauxverideShim < ComGoogleCommonCollectSortedMultiset > {
 @public
  ComGoogleCommonCollectImmutableSortedMultiset *descendingMultiset_;
}

#pragma mark Public

- (id<JavaUtilComparator>)comparator;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)copyOfWithJavaUtilComparator:(id<JavaUtilComparator>)comparator
                                                           withJavaLangIterable:(id<JavaLangIterable>)elements OBJC_METHOD_FAMILY_NONE;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)copyOfWithJavaUtilComparator:(id<JavaUtilComparator>)comparator
                                                           withJavaUtilIterator:(id<JavaUtilIterator>)elements OBJC_METHOD_FAMILY_NONE;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)copyOfWithJavaLangComparableArray:(IOSObjectArray *)elements OBJC_METHOD_FAMILY_NONE;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)copyOfWithJavaLangIterable:(id<JavaLangIterable>)elements OBJC_METHOD_FAMILY_NONE;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)copyOfWithJavaUtilIterator:(id<JavaUtilIterator>)elements OBJC_METHOD_FAMILY_NONE;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)copyOfSortedWithComGoogleCommonCollectSortedMultiset:(id<ComGoogleCommonCollectSortedMultiset>)sortedMultiset OBJC_METHOD_FAMILY_NONE;

- (ComGoogleCommonCollectImmutableSortedMultiset *)descendingMultiset;

- (ComGoogleCommonCollectImmutableSortedSet *)elementSet;

- (ComGoogleCommonCollectImmutableSortedMultiset *)headMultisetWithId:(id)upperBound
                              withComGoogleCommonCollectBoundTypeEnum:(ComGoogleCommonCollectBoundTypeEnum *)boundType;

+ (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)naturalOrder;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)of;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)ofWithJavaLangComparable:(id<JavaLangComparable>)element;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)ofWithJavaLangComparable:(id<JavaLangComparable>)e1
                                                     withJavaLangComparable:(id<JavaLangComparable>)e2;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)ofWithJavaLangComparable:(id<JavaLangComparable>)e1
                                                     withJavaLangComparable:(id<JavaLangComparable>)e2
                                                     withJavaLangComparable:(id<JavaLangComparable>)e3;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)ofWithJavaLangComparable:(id<JavaLangComparable>)e1
                                                     withJavaLangComparable:(id<JavaLangComparable>)e2
                                                     withJavaLangComparable:(id<JavaLangComparable>)e3
                                                     withJavaLangComparable:(id<JavaLangComparable>)e4;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)ofWithJavaLangComparable:(id<JavaLangComparable>)e1
                                                     withJavaLangComparable:(id<JavaLangComparable>)e2
                                                     withJavaLangComparable:(id<JavaLangComparable>)e3
                                                     withJavaLangComparable:(id<JavaLangComparable>)e4
                                                     withJavaLangComparable:(id<JavaLangComparable>)e5;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)ofWithJavaLangComparable:(id<JavaLangComparable>)e1
                                                     withJavaLangComparable:(id<JavaLangComparable>)e2
                                                     withJavaLangComparable:(id<JavaLangComparable>)e3
                                                     withJavaLangComparable:(id<JavaLangComparable>)e4
                                                     withJavaLangComparable:(id<JavaLangComparable>)e5
                                                     withJavaLangComparable:(id<JavaLangComparable>)e6
                                                withJavaLangComparableArray:(IOSObjectArray *)remaining;

+ (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)orderedByWithJavaUtilComparator:(id<JavaUtilComparator>)comparator;

- (id<ComGoogleCommonCollectMultiset_Entry>)pollFirstEntry;

- (id<ComGoogleCommonCollectMultiset_Entry>)pollLastEntry;

+ (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)reverseOrder;

- (ComGoogleCommonCollectImmutableSortedMultiset *)subMultisetWithId:(id)lowerBound
                             withComGoogleCommonCollectBoundTypeEnum:(ComGoogleCommonCollectBoundTypeEnum *)lowerBoundType
                                                              withId:(id)upperBound
                             withComGoogleCommonCollectBoundTypeEnum:(ComGoogleCommonCollectBoundTypeEnum *)upperBoundType;

- (ComGoogleCommonCollectImmutableSortedMultiset *)tailMultisetWithId:(id)lowerBound
                              withComGoogleCommonCollectBoundTypeEnum:(ComGoogleCommonCollectBoundTypeEnum *)boundType;

#pragma mark Package-Private

- (instancetype)init;

+ (ComGoogleCommonCollectImmutableSortedMultiset *)emptyMultisetWithJavaUtilComparator:(id<JavaUtilComparator>)comparator;

- (id)writeReplace;

@end

J2OBJC_STATIC_INIT(ComGoogleCommonCollectImmutableSortedMultiset)

J2OBJC_FIELD_SETTER(ComGoogleCommonCollectImmutableSortedMultiset, descendingMultiset_, ComGoogleCommonCollectImmutableSortedMultiset *)

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_of();

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_ofWithJavaLangComparable_(id<JavaLangComparable> element);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_ofWithJavaLangComparable_withJavaLangComparable_(id<JavaLangComparable> e1, id<JavaLangComparable> e2);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_ofWithJavaLangComparable_withJavaLangComparable_withJavaLangComparable_(id<JavaLangComparable> e1, id<JavaLangComparable> e2, id<JavaLangComparable> e3);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_ofWithJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparable_(id<JavaLangComparable> e1, id<JavaLangComparable> e2, id<JavaLangComparable> e3, id<JavaLangComparable> e4);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_ofWithJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparable_(id<JavaLangComparable> e1, id<JavaLangComparable> e2, id<JavaLangComparable> e3, id<JavaLangComparable> e4, id<JavaLangComparable> e5);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_ofWithJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparable_withJavaLangComparableArray_(id<JavaLangComparable> e1, id<JavaLangComparable> e2, id<JavaLangComparable> e3, id<JavaLangComparable> e4, id<JavaLangComparable> e5, id<JavaLangComparable> e6, IOSObjectArray *remaining);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_copyOfWithJavaLangComparableArray_(IOSObjectArray *elements);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_copyOfWithJavaLangIterable_(id<JavaLangIterable> elements);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_copyOfWithJavaUtilIterator_(id<JavaUtilIterator> elements);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_copyOfWithJavaUtilComparator_withJavaUtilIterator_(id<JavaUtilComparator> comparator, id<JavaUtilIterator> elements);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_copyOfWithJavaUtilComparator_withJavaLangIterable_(id<JavaUtilComparator> comparator, id<JavaLangIterable> elements);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_copyOfSortedWithComGoogleCommonCollectSortedMultiset_(id<ComGoogleCommonCollectSortedMultiset> sortedMultiset);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset *ComGoogleCommonCollectImmutableSortedMultiset_emptyMultisetWithJavaUtilComparator_(id<JavaUtilComparator> comparator);

FOUNDATION_EXPORT void ComGoogleCommonCollectImmutableSortedMultiset_init(ComGoogleCommonCollectImmutableSortedMultiset *self);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset_Builder *ComGoogleCommonCollectImmutableSortedMultiset_orderedByWithJavaUtilComparator_(id<JavaUtilComparator> comparator);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset_Builder *ComGoogleCommonCollectImmutableSortedMultiset_reverseOrder();

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset_Builder *ComGoogleCommonCollectImmutableSortedMultiset_naturalOrder();

J2OBJC_TYPE_LITERAL_HEADER(ComGoogleCommonCollectImmutableSortedMultiset)

#endif

#if !defined (_ComGoogleCommonCollectImmutableSortedMultiset_Builder_) && (ComGoogleCommonCollectImmutableSortedMultiset_INCLUDE_ALL || ComGoogleCommonCollectImmutableSortedMultiset_Builder_INCLUDE)
#define _ComGoogleCommonCollectImmutableSortedMultiset_Builder_

#define ComGoogleCommonCollectImmutableMultiset_RESTRICT 1
#define ComGoogleCommonCollectImmutableMultiset_Builder_INCLUDE 1
#include "com/google/common/collect/ImmutableMultiset.h"

@class ComGoogleCommonCollectImmutableSortedMultiset;
@class IOSObjectArray;
@protocol JavaLangIterable;
@protocol JavaUtilComparator;
@protocol JavaUtilIterator;

@interface ComGoogleCommonCollectImmutableSortedMultiset_Builder : ComGoogleCommonCollectImmutableMultiset_Builder

#pragma mark Public

- (instancetype)initWithJavaUtilComparator:(id<JavaUtilComparator>)comparator;

- (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)addWithId:(id)element;

- (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)addWithNSObjectArray:(IOSObjectArray *)elements;

- (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)addAllWithJavaLangIterable:(id<JavaLangIterable>)elements;

- (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)addAllWithJavaUtilIterator:(id<JavaUtilIterator>)elements;

- (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)addCopiesWithId:(id)element
                                                                   withInt:(jint)occurrences;

- (ComGoogleCommonCollectImmutableSortedMultiset *)build;

- (ComGoogleCommonCollectImmutableSortedMultiset_Builder *)setCountWithId:(id)element
                                                                  withInt:(jint)count;

@end

J2OBJC_EMPTY_STATIC_INIT(ComGoogleCommonCollectImmutableSortedMultiset_Builder)

FOUNDATION_EXPORT void ComGoogleCommonCollectImmutableSortedMultiset_Builder_initWithJavaUtilComparator_(ComGoogleCommonCollectImmutableSortedMultiset_Builder *self, id<JavaUtilComparator> comparator);

FOUNDATION_EXPORT ComGoogleCommonCollectImmutableSortedMultiset_Builder *new_ComGoogleCommonCollectImmutableSortedMultiset_Builder_initWithJavaUtilComparator_(id<JavaUtilComparator> comparator) NS_RETURNS_RETAINED;

J2OBJC_TYPE_LITERAL_HEADER(ComGoogleCommonCollectImmutableSortedMultiset_Builder)

#endif

#pragma pop_macro("ComGoogleCommonCollectImmutableSortedMultiset_INCLUDE_ALL")


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>org.puremvc.as3.multicore.patterns.command - API Documentation</title>
<base target="classFrame">
<link rel="stylesheet" href="../../../../../../style.css" type="text/css" media="screen">
<link rel="stylesheet" href="../../../../../../print.css" type="text/css" media="print">

Package org.puremvc.as3.multicore.patterns.command

Classes

MacroCommandTest

MacroCommandTestCommand

MacroCommandTestSub1Command

MacroCommandTestSub2Command

MacroCommandTestVO

SimpleCommandTest

SimpleCommandTestCommand

SimpleCommandTestVO


text:
#ifndef __PRINTSYSTEMATTRIBUTEVALUE_HPP__
#define __PRINTSYSTEMATTRIBUTEVALUE_HPP__

namespace System
{
namespace Printing
{
namespace IndexedProperties
{
    /// <summary>
    /// PrintProperty object.
    /// This is the class that abstracts a property-value pair and allows representing
    //  any type that the Print System supports through a common interface.
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    public ref class PrintProperty abstract :
    public IDisposable,
    public System::Runtime::Serialization::IDeserializationCallback
    {
        public:

        /// <summary>
        /// PrintProperty destructor.
        /// </summary>
        ~PrintProperty(
            );

        /// <value>
        /// Name identifier of this object.
        /// </value>
        /// <remarks>
        /// Inherited from PrintSystemObject.
        /// </remarks>
        property
        virtual
        String^
        Name
        {
            String^ get();
        }

        /// <value>
        /// Object representing the value of the property-value pair  represented by this object.
        /// </value>
        property
        virtual
        Object^
        Value
        {
            Object^ get() = 0;
            void set(Object^ objValue) = 0;
        }

        property
        bool
        IsInitialized
        {
            internal:
                bool get();

            protected:
                void set(bool setInitialized);
        }

        virtual void
        OnDeserialization(
            Object^ sender
            );

        internal:

        delegate
        PrintProperty^
        CreateWithNoValue(
            String^  attributeName
            );

        delegate
        PrintProperty^
        CreateWithValue(
            String^  attributeName,
            Object^  attributeValue
            );

        delegate
        PrintProperty^
        CreateWithNoValueLinked(
            String^             attributeName,
            MulticastDelegate^  delegate
            );

        delegate
        PrintProperty^
        CreateWithValueLinked(
            String^             attributeName,
            Object^             attributeValue,
            MulticastDelegate^  delegate
            );

        // FIX: remove pragma. done to fix compiler error which will be fixed later.
        #pragma warning ( disable:4376 )

        property
        bool
        IsInternallyInitialized
        {
            bool get();
            void set(bool);
        }

        property
        bool
        IsDirty
        {
            bool get();
            void set(bool setDirty);
        }

        property
        bool
        IsLinked
        {
            bool get();
            void set(bool setLinked);
        }

        #pragma warning ( default:4376 )

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            );

        /// <summary>
        /// PrintProperty finalizer.
        /// </summary>
        !PrintProperty(
            );

        property
        bool
        IsDisposed
        {
            bool get();
            void set(bool disposing);
        }

        /// <summary>
        /// Initialize the instance of the base PrintProperty class.
        /// </summary>
        /// <param name="attributeName"> Attribute name. </param>
        PrintProperty(
            String^ attributeName
            );

        private:

        String^ propertyName;
        Object^ syncRoot;
        bool    isDirty;
        bool    isDisposed;
        bool    isInitialized;
        bool    isInternallyInitialized;
        bool    isLinked;
    };

    /// <summary>
    /// PrintInt32Property object.
    /// This is the class that represents a property-numeric value pair.
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintInt32Property sealed :
    public PrintProperty
    {
        public:

        PrintInt32Property(
            String^ attributeName
            );

        PrintInt32Property(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintInt32Property(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintInt32Property(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;

            ///<SecurityNote>
            /// Critical    - Unverifiable pointer access
            ///</SecurityNote>
            [SecurityCritical]
            [SecurityPermission(SecurityAction::Assert, UnmanagedCode=true)]
            virtual void set(Object^ objValue) override;
        }

        internal:

        // FIX: remove pragma. done to fix compiler error which will be fixed later.
        #pragma warning ( disable:4376 )

        property
        PrintSystemDelegates::Int32ValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::Int32ValueChanged^ get();
            void set(PrintSystemDelegates::Int32ValueChanged^ newHandler);
        }

        public:

        static
        operator
        Int32(
            PrintInt32Property % attribRef
            );

        static
        operator
        Int32(
            PrintInt32Property ^ attribRef
            );

        internal:

        static
        Int32^
        ToInt32(
            PrintInt32Property % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::Int32ValueChanged^     changeHandler;
        Int32                                        value;
    };

    /// <summary>
    /// PrintStringProperty object.
    /// This is the class that represents a property-string value pair.
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    public ref class PrintStringProperty sealed :
    public PrintProperty
    {
        public:

        PrintStringProperty(
            String^ attributeName
            );

        PrintStringProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintStringProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintStringProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::StringValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::StringValueChanged^ get();
            void set(PrintSystemDelegates::StringValueChanged^ newHandler);
        }

        public:

        static
        operator
        String^(
            PrintStringProperty^ attributeRef
            );

        static
        operator
        String^(
            PrintStringProperty% attributeRef
            );

        internal:

        static
        String^
        ToString(
            PrintStringProperty % attributeRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::StringValueChanged^    changeHandler;
        String^                                      value;
    };

    /// <summary>
    /// PrintStreamProperty object.
    /// This is the class that represents a property-stream value pair.
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    public ref class PrintStreamProperty sealed :
    public PrintProperty
    {
        public:

        PrintStreamProperty(
            String^ attributeName
            );

        PrintStreamProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintStreamProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintStreamProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::StreamValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::StreamValueChanged^ get();
            void set(PrintSystemDelegates::StreamValueChanged^ newHandler);
        }

        public:

        static
        operator
        Stream^(
            PrintStreamProperty % attributeRef
            );

        static
        operator
        Stream^(
            PrintStreamProperty^ attributeRef
            );

        internal:

        static
        Stream^
        ToStream(
            PrintStreamProperty % attributeRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::StreamValueChanged^    changeHandler;
        Stream^                                      value;
    };

    /// <summary>
    /// PrintQueueAttributeProperty object.
    /// This is the class that represents a property - <c>PrintQueueAttributes</c> value pair.
    /// <see cref="PrintQueueAttributes"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintQueueAttributeProperty sealed :
    public PrintProperty
    {
        public:

        PrintQueueAttributeProperty(
            String^ attributeName
            );

        PrintQueueAttributeProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintQueueAttributeProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintQueueAttributeProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintQueueAttributePropertyChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PrintQueueAttributePropertyChanged^ get();
            void set(PrintSystemDelegates::PrintQueueAttributePropertyChanged^ newHandler);
        }

        public:

        static
        operator
        PrintQueueAttributes(
            PrintQueueAttributeProperty % attributeRef
            );

        static
        operator
        PrintQueueAttributes(
            PrintQueueAttributeProperty^ attributeRef
            );

        internal:

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PrintQueueAttributePropertyChanged^   changeHandler;
        PrintQueueAttributes                                        value;
    };

    /// <summary>
    /// PrintQueueStatusProperty object.
    /// This is the class that represents a property-<c>PrintQueueStatus</c> value pair.
    /// <see cref="PrintQueueStatus"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintQueueStatusProperty sealed :
    public PrintProperty
    {
        public:

        PrintQueueStatusProperty(
            String^ attributeName
            );

        PrintQueueStatusProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintQueueStatusProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintQueueStatusProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintQueueStatusValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PrintQueueStatusValueChanged^ get();
            void set(PrintSystemDelegates::PrintQueueStatusValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintQueueStatus(
            PrintQueueStatusProperty^ attributeRef
            );

        static
        operator
        PrintQueueStatus(
            PrintQueueStatusProperty % attributeRef
            );

        internal:

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PrintQueueStatusValueChanged^     changeHandler;
        PrintQueueStatus                                        value;
    };

    /// <summary>
    /// PrintBooleanProperty object.
    /// This is the class that represents a property-<c>Boolean</c> value pair.
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintBooleanProperty sealed :
    public PrintProperty
    {
        public:

        PrintBooleanProperty(
            String^ attributeName
            );

        PrintBooleanProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintBooleanProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintBooleanProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;

            ///<SecurityNote>
            /// Critical    - Unverifiable pointer access
            ///</SecurityNote>
            [SecurityCritical]
            [SecurityPermission(SecurityAction::Assert, UnmanagedCode=true)]
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::BooleanValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::BooleanValueChanged^ get();
            void set(PrintSystemDelegates::BooleanValueChanged^ newHandler);
        }

        public:

        static
        operator
        Boolean(
            PrintBooleanProperty % attribRef
            );

        static
        operator
        Boolean(
            PrintBooleanProperty^ attribRef
            );

        internal:

        static
        Boolean^
        ToBoolean(
            PrintBooleanProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::BooleanValueChanged^     changeHandler;
        Boolean                                        value;
    };

    /// <summary>
    /// PrintThreadPriorityProperty object.
    /// This is the class that represents a property-<c>ThreadPriority</c> value pair.
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintThreadPriorityProperty sealed :
    public PrintProperty
    {
        public:

        PrintThreadPriorityProperty(
            String^ attributeName
            );

        PrintThreadPriorityProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintThreadPriorityProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintThreadPriorityProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;

            ///<SecurityNote>
            /// Critical    - Unverifiable pointer access
            ///</SecurityNote>
            [SecurityCritical]
            [SecurityPermission(SecurityAction::Assert, UnmanagedCode=true)]
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::ThreadPriorityValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::ThreadPriorityValueChanged^ get();
            void set(PrintSystemDelegates::ThreadPriorityValueChanged^ newHandler);
        }

        public:

        static
        operator
        System::Threading::ThreadPriority(
            PrintThreadPriorityProperty % attribRef
            );

        static
        operator
        System::Threading::ThreadPriority(
            PrintThreadPriorityProperty^ attribRef
            );

        internal:

        static
        System::Threading::ThreadPriority^
        ToThreadPriority(
            PrintThreadPriorityProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::ThreadPriorityValueChanged^     changeHandler;
        System::Threading::ThreadPriority                     value;
    };

    /// <summary>
    /// PrintServerLoggingProperty object.
    /// This is the class that represents a property-<c>PrintServerEventLoggingTypes</c> value pair.
    /// <see cref="PrintServerEventLoggingTypes"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintServerLoggingProperty sealed :
    public PrintProperty
    {
        public:

        PrintServerLoggingProperty(
            String^ attributeName
            );

        PrintServerLoggingProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintServerLoggingProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintServerLoggingProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;

            ///<SecurityNote>
            /// Critical    - Unverifiable pointer access
            ///</SecurityNote>
            [SecurityCritical]
            [SecurityPermission(SecurityAction::Assert, UnmanagedCode=true)]
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintServerEventLoggingValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PrintServerEventLoggingValueChanged^ get();
            void set(PrintSystemDelegates::PrintServerEventLoggingValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintServerEventLoggingTypes(
            PrintServerLoggingProperty % attribRef
            );

        static
        operator
        PrintServerEventLoggingTypes(
            PrintServerLoggingProperty^ attribRef
            );

        internal:

        static
        PrintServerEventLoggingTypes^
        ToPrintServerEventLoggingTypes(
            PrintServerLoggingProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PrintServerEventLoggingValueChanged^     changeHandler;
        PrintServerEventLoggingTypes                                   value;
    };

    /// <summary>
    /// PrintDriverProperty object.
    /// This is the class that represents a property-<c>Driver</c> value pair.
    /// <see cref="Driver"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintDriverProperty sealed :
    public PrintProperty
    {
        public:

        PrintDriverProperty(
            String^ attributeName
            );

        PrintDriverProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintDriverProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintDriverProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::DriverValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::DriverValueChanged^ get();
            void set(PrintSystemDelegates::DriverValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintDriver^(
            PrintDriverProperty % attribRef
            );

        static
        operator
        PrintDriver^(
            PrintDriverProperty^ attribRef
            );

        internal:

        static
        PrintDriver^
        ToPrintDriver(
            PrintDriverProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::DriverValueChanged^     changeHandler;
        PrintDriver^                                  value;
    };

    /// <summary>
    /// PrintPortProperty object.
    /// This is the class that represents a property-<c>Port</c> value pair.
    /// <see cref="Port"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintPortProperty sealed :
    public PrintProperty
    {
        public:

        PrintPortProperty(
            String^ attributeName
            );

        PrintPortProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintPortProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintPortProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PortValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PortValueChanged^ get();
            void set(PrintSystemDelegates::PortValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintPort^(
            PrintPortProperty % attribRef
            );

        static
        operator
        PrintPort^(
            PrintPortProperty^ attribRef
            );

        internal:

        static
        PrintPort^
        ToPrintPort(
            PrintPortProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PortValueChanged^     changeHandler;
        PrintPort^                                value;
    };

    /// <summary>
    /// PrintServerProperty object.
    /// This is the class that represents a property-<c>PrintServer</c> value pair.
    /// <see cref="PrintServer"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintServerProperty sealed :
    public PrintProperty
    {
        public:

        PrintServerProperty(
            String^ attributeName
            );

        PrintServerProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintServerProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintServerProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintServerValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PrintServerValueChanged^ get();
            void set(PrintSystemDelegates::PrintServerValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintServer^(
            PrintServerProperty % attribRef
            );

        static
        operator
        PrintServer^(
            PrintServerProperty^ attribRef
            );

        internal:

        static
        PrintServer^
        ToPrintServer(
            PrintServerProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PrintServerValueChanged^     changeHandler;
        PrintServer^                                       value;
    };

    /// <summary>
    /// PrintTicketProperty object.
    /// This is the class that represents a property-<c>PrintTicket</c> value pair.
    /// <see cref="PrintTicket"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintTicketProperty sealed :
    public PrintProperty
    {
        public:

        ///<SecurityNote>
        /// Critical    :   References type from non-APTCA reachframework.dll (PrintTicket)
        /// PublicOK :   Type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        PrintTicketProperty(
            String^ attributeName
            );

        ///<SecurityNote>
        /// Critical    :   References type from non-APTCA reachframework.dll (PrintTicket)
        /// PublicOK :   Type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        PrintTicketProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        ///<SecurityNote>
        /// Critical    :   References critical delegate (PrintTicketValueChanged)
        /// TreatAsSafe :   Delegate is critical because its signature contains the safe PrintTicket type from non-APTCA reachframework.dll
        ///                 However the PrintTicket type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        PrintTicketProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        ///<SecurityNote>
        /// Critical    :   References type from non-APTCA reachframework.dll (PrintTicket)
        /// TreatAsSafe :   Type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        PrintTicketProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            /// <SecurityNote>
            ///    Critical - Uses type from non-APTCA reachframework.dll (PrintTicket)
            ///    PublicOK 	- Type is safe
            /// <SecurityNote>
            [SecuritySafeCritical]
            virtual Object^ get() override;

            /// <SecurityNote>
            ///    Critical - Uses type from non-APTCA reachframework.dll (PrintTicket)
            ///    PublicOK 	- Type is safe
            /// <SecurityNote>
            [SecuritySafeCritical]
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintTicketValueChanged^
        ChangeHandler
        {
            ///<SecurityNote>
            /// Critical    :   Returns critical delegate (PrintTicketValueChanged)
            /// TreatAsSafe :   Delegate is critical because its signature contains the safe PrintTicket type from non-APTCA reachframework.dll
            ///</SecurityNote>
            [SecuritySafeCritical]
            PrintSystemDelegates::PrintTicketValueChanged^ get();

            ///<SecurityNote>
            /// Critical    :   References critical delegate (PrintTicketValueChanged)
            /// TreatAsSafe :   Delegate is critical because its signature contains the safe PrintTicket type from non-APTCA reachframework.dll
            ///</SecurityNote>
            [SecuritySafeCritical]
            void set(PrintSystemDelegates::PrintTicketValueChanged^ newHandler);
        }

        public:

        ///<SecurityNote>
        ///    Critical - Uses type from non-APTCA reachframework.dll (PrintTicket)
        ///    PublicOK  - Type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        static
        operator
        PrintTicket^(
            PrintTicketProperty % attribRef
            );

        ///<SecurityNote>
        ///    Critical - Uses type from non-APTCA reachframework.dll (PrintTicket)
        ///    PublicOK  - Type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        static
        operator
        PrintTicket^(
            PrintTicketProperty^ attribRef
            );

        internal:

        ///<SecurityNote>
        ///    Critical - Uses type from non-APTCA reachframework.dll (PrintTicket)
        /// TreatAsSafe  - Type is safe
        ///</SecurityNote>
        [SecuritySafeCritical]
        static
        PrintTicket^
        ToPrintTicket(
            PrintTicketProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        ///<SecurityNote>
        /// Critical    :   Sets critical delegate field (of type PrintTicketValueChanged)
        /// TreatAsSafe :   - Delegate is critical because its signature contains type from non-APTCA reachframework.dll (PrintTicket)
	///                   However PrintTicket type is safe.
	///                 - Delegate is set to safe value (null)
        ///</SecurityNote>
        [SecuritySafeCritical]
        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        ///<SecurityNote>
        /// Critical    :   Field for critical delegate (PrintTicketValueChanged)
        ///</SecurityNote>
        [SecurityCritical]
        PrintSystemDelegates::PrintTicketValueChanged^     changeHandler;

        ///<SecurityNote>
        /// Critical    :   Field for critical type (PrintTicket)
        ///</SecurityNote>
        [SecurityCritical]
        PrintTicket^                                       value;
    };

    /// <summary>
    /// PrintByteArrayProperty object.
    /// This is the class that represents a property-<c>Byte[]</c> value pair.
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintByteArrayProperty sealed :
    public PrintProperty
    {
        public:

        PrintByteArrayProperty(
            String^ attributeName
            );

        PrintByteArrayProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintByteArrayProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintByteArrayProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::ByteArrayValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::ByteArrayValueChanged^ get();
            void set(PrintSystemDelegates::ByteArrayValueChanged^ newHandler);
        }

        public:

        static
        operator
        array<Byte>^(
            PrintByteArrayProperty % attribRef
            );

        static
        operator
        array<Byte>^(
            PrintByteArrayProperty^ attribRef
            );

        internal:

        static
        array<Byte>^
        ToByteArray(
            PrintByteArrayProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::ByteArrayValueChanged^   changeHandler;
        array<Byte>^                                   value;
    };

    /// <summary>
    /// PrintProcessorProperty object.
    /// This is the class that represents a property-<c>PrintProcessor</c> value pair.
    /// <see cref="PrintProcessor"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintProcessorProperty sealed :
    public PrintProperty
    {
        public:

        PrintProcessorProperty(
            String^ attributeName
            );

        PrintProcessorProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintProcessorProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintProcessorProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintProcessorValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PrintProcessorValueChanged^ get();
            void set(PrintSystemDelegates::PrintProcessorValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintProcessor^(
            PrintProcessorProperty % attribRef
            );

        static
        operator
        PrintProcessor^(
            PrintProcessorProperty^ attribRef
            );

        internal:

        static
        PrintProcessor^
        ToPrintProcessor(
            PrintProcessorProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PrintProcessorValueChanged^     changeHandler;
        PrintProcessor^                                       value;
    };

    /// <summary>
    /// PrintQueueProperty object.
    /// This is the class that represents a property-<c>PrintQueue</c> value pair.
    /// <see cref="PrintQueue"/>
    /// </summary>
    /// <ExternalAPI/>
    public ref class PrintQueueProperty sealed :
    public PrintProperty
    {
        public:

        PrintQueueProperty(
            String^ attributeName
            );

        PrintQueueProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintQueueProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintQueueProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::PrintQueueValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::PrintQueueValueChanged^ get();
            void set(PrintSystemDelegates::PrintQueueValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintQueue^(
            PrintQueueProperty % attribRef
            );

        static
        operator
        PrintQueue^(
            PrintQueueProperty^ attribRef
            );

        internal:

        static
        PrintQueue^
        ToPrintQueue(
            PrintQueueProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        PrintSystemDelegates::PrintQueueValueChanged^     changeHandler;
        PrintQueue^                                       value;
    };

    /// <summary>
    /// PrintJobPriorityProperty object.
    /// This is the class that represents a property-<c>PrintJobPriority</c> value pair.
    /// <see cref="PrintQueue"/>
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    public ref class PrintJobPriorityProperty sealed :
    public PrintProperty
    {
        public:

        PrintJobPriorityProperty(
            String^ attributeName
            );

        PrintJobPriorityProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintJobPriorityProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintJobPriorityProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::JobPriorityValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::JobPriorityValueChanged^ get();
            void set(PrintSystemDelegates::JobPriorityValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintJobPriority(
            PrintJobPriorityProperty % attribRef
            );

        static
        operator
        PrintJobPriority(
            PrintJobPriorityProperty^ attribRef
            );

        internal:

        static
        PrintJobPriority^
        ToPrintJobPriority(
            PrintJobPriorityProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::JobPriorityValueChanged^     changeHandler;
        PrintJobPriority                                   value;
    };

    /// <summary>
    /// PrintSystemJobTypeAttributeValue object.
    /// PrintJobStatusProperty object.
    /// This is the class that represents a property-<c>PrintJobType</c> value pair.
    /// <see cref="PrintQueue"/>
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    private ref class PrintSystemJobTypeAttributeValue sealed :
    public PrintProperty
    {
        public:

        PrintSystemJobTypeAttributeValue(
            String^ attributeName
            );

        PrintSystemJobTypeAttributeValue(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintSystemJobTypeAttributeValue(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintSystemJobTypeAttributeValue(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::JobTypeValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::JobTypeValueChanged^ get();
            void set(PrintSystemDelegates::JobTypeValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintJobType(
            PrintSystemJobTypeAttributeValue % attribRef
            );

        static
        operator
        PrintJobType(
            PrintSystemJobTypeAttributeValue^ attribRef
            );

        internal:

        static
        PrintJobType^
        ToPrintJobType(
            PrintSystemJobTypeAttributeValue % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::JobTypeValueChanged^          changeHandler;
        PrintJobType                                        value;
    };

    /// <summary>
    /// PrintJobStatusProperty object.
    /// This is the class that represents a property-<c>PrintJobStatus</c> value pair.
    /// <see cref="PrintQueue"/>
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    public ref class PrintJobStatusProperty sealed :
    public PrintProperty
    {
        public:

        PrintJobStatusProperty(
            String^ attributeName
            );

        PrintJobStatusProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintJobStatusProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintJobStatusProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::JobStatusValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::JobStatusValueChanged^ get();
            void set(PrintSystemDelegates::JobStatusValueChanged^ newHandler);
        }

        public:

        static
        operator
        PrintJobStatus(
            PrintJobStatusProperty % attribRef
            );

        static
        operator
        PrintJobStatus(
            PrintJobStatusProperty^ attribRef
            );

        internal:

        static
        PrintJobStatus^
        ToPrintJobStatus(
            PrintJobStatusProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::JobStatusValueChanged^       changeHandler;
        PrintJobStatus                                      value;
    };

    /// <summary>
    /// PrintJobPriorityProperty object.
    /// This is the class that represents a property-<c>PrintJobPriority</c> value pair.
    /// <see cref="PrintQueue"/>
    /// </summary>
    /// <ExternalAPI/>
    [System::Serializable]
    public ref class PrintDateTimeProperty sealed :
    public PrintProperty
    {
        public:

        PrintDateTimeProperty(
            String^ attributeName
            );

        PrintDateTimeProperty(
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintDateTimeProperty(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintDateTimeProperty(
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::SystemDateTimeValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::SystemDateTimeValueChanged^ get();
            void set(PrintSystemDelegates::SystemDateTimeValueChanged^ newHandler);
        }

        public:

        static
        operator
        System::DateTime^(
            PrintDateTimeProperty % attribRef
            );

        static
        operator
        System::DateTime^(
            PrintDateTimeProperty^ attribRef
            );

        internal:

        static
        System::DateTime^
        ToDateTime(
            PrintDateTimeProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::SystemDateTimeValueChanged^     changeHandler;
        System::DateTime                                      value;
    };

    [System::Serializable]
    public ref class PrintSystemTypeProperty sealed :
    public PrintProperty
    {
        public:

        PrintSystemTypeProperty (
            String^ attributeName
            );

        PrintSystemTypeProperty (
            String^ attributeName,
            Object^ attributeValue
            );

        internal:

        PrintSystemTypeProperty (
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        PrintSystemTypeProperty (
            String^            attributeName,
            Object^            attributeValue,
            MulticastDelegate^ delegate
            );

        public:

        property
        Object^
        Value
        {
            virtual Object^ get() override;
            virtual void set(Object^ objValue) override;
        }

        internal:

        property
        PrintSystemDelegates::SystemTypeValueChanged^
        ChangeHandler
        {
            PrintSystemDelegates::SystemTypeValueChanged^ get();
            void set(PrintSystemDelegates::SystemTypeValueChanged^ newHandler);
        }

        #pragma warning ( default:4376 )

        public:

        static
        operator
        System::Type^(
            PrintSystemTypeProperty % attribRef
            );

        static
        operator
        System::Type^(
            PrintSystemTypeProperty^ attribRef
            );

        internal:

        static
        System::Type^
        ToType(
            PrintSystemTypeProperty % attribRef
            );

        static
        PrintProperty^
        Create(
            String^ attributeName
            );

        static
        PrintProperty^
        Create(
            String^ attributeName,
            Object^ attributeValue
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            MulticastDelegate^ delegate
            );

        static
        PrintProperty^
        Create(
            String^            attributeName,
            Object^            attribValue,
            MulticastDelegate^ delegate
            );

        protected:

        virtual
        void
        InternalDispose(
            bool disposing
            ) override;

        private:

        [NonSerialized]
        PrintSystemDelegates::SystemTypeValueChanged^     changeHandler;
        System::Type^                                     value;
    };

    /// <summary>
    /// This is the class that abstracts a collection of properties
    /// associated with an object in the Printing namespace.
    /// </summary>
    /// <ExternalAPI/>
    [DefaultMember("Property")]
    [System::Serializable]
    public ref class PrintPropertyDictionary :
    public Hashtable,
    public System::Runtime::Serialization::ISerializable ,
    public System::Runtime::Serialization::IDeserializationCallback
    {
        public:

        /// <summary>
        /// PrintPropertyDictionary constructor.
        /// </summary>
        PrintPropertyDictionary(
            void
            );

        /// <summary>
        /// PrintPropertyDictionary destructor.
        /// </summary>
        ~PrintPropertyDictionary(
            );

        /// <summary>
        /// Adds a PrintProperty to the collection.
        /// </summary>
        void
        Add(
            PrintProperty^ attributeValue
            );

        virtual void
        OnDeserialization(
            Object^ sender
            ) override;

        ///<SecurityNote>
        /// Critical    :   Base method is critical
        ///</SecurityNote>
        [SecurityCritical]
        virtual void
        GetObjectData(
            System::
            Runtime::
            Serialization::
            SerializationInfo^ info,
            System::
            Runtime::
            Serialization::
            StreamingContext   context
            ) override;

        /// <summary>
        /// Returns the PrintProperty object identified by the attribName.
        /// </summary>
        PrintProperty^
        GetProperty(
            String^ attribName
            );

        void
        SetProperty(
            String^ attribName,
            PrintProperty^ attribValue
            );

        protected:

        PrintPropertyDictionary(
            System::
            Runtime::
            Serialization::
            SerializationInfo^ info,
            System::
            Runtime::
            Serialization::
            StreamingContext   context
            );

    };
}
}
}

#endif


text:
//
//  UIDevice_MKAdditions.m
//  DeviceHelper
//
//  Created by Mugunth Kumar on 15-Aug-10.
//  Copyright 2010 Steinlogic. All rights reserved.
//  As a side note on using this code, you might consider giving some credit to me by
//	1) linking my website from your app's website
//	2) or crediting me inside the app's credits page
//	3) or a tweet mentioning @mugunthkumar
//	4) A paypal donation to mugunth.kumar@gmail.com
//
//  A note on redistribution
//	if you are re-publishing after editing, please retain the above copyright notices

#import "UIDevice+MKAdditions.h"

@implementation UIDevice (MKAdditions)

- (BOOL)isSimulator { // by Sam Soffes

	static NSString *simulatorModel = @"iPhone Simulator";

	return [[self model] isEqual:simulatorModel];
}

- (BOOL) microphoneAvailable
{
	AVAudioSession *ptr = [AVAudioSession sharedInstance];
	return ptr.inputIsAvailable;
}

- (void) vibrateWithSound
{
	AudioServicesPlayAlertSound(kSystemSoundID_Vibrate);
}

-(void) vibrateWithoutSound
{
	AudioServicesPlaySystemSound(kSystemSoundID_Vibrate);
}

- (BOOL) doesPhotoLibraryHavePictures
{
	return [UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypePhotoLibrary];
}

- (BOOL) doesCameraRollHavePictures
{
	return [UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypeSavedPhotosAlbum];
}

- (BOOL) cameraAvailable
{
	return [UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera];
}

- (BOOL) videoCameraAvailable
{
	UIImagePickerController *picker = [[UIImagePickerController alloc] init];
	NSArray *sourceTypes = [UIImagePickerController availableMediaTypesForSourceType:picker.sourceType];
	[picker release];

	if (![sourceTypes containsObject:(NSString *)kUTTypeMovie ]){

		return NO;
	}

	return YES;
}

- (BOOL) frontCameraAvailable
{
#ifdef __IPHONE_4_0
	return [UIImagePickerController isCameraDeviceAvailable:UIImagePickerControllerCameraDeviceFront];
#else
	return NO;
#endif

}

- (BOOL) cameraFlashAvailable
{
#ifdef __IPHONE_4_0
	return [UIImagePickerController isFlashAvailableForCameraDevice:UIImagePickerControllerCameraDeviceRear];
#else
	return NO;
#endif
}

// later when Apple adds a camera flash to the front camera in iPhone 5 or 6 or whatever, this function can be uncommented :)
/*
- (BOOL) isCameraFlashAvailableForFrontCamera
{
#ifdef __IPHONE_5_0 or 6?!?
	return [UIImagePickerController isFlashAvailableForCameraDevice:UIImagePickerControllerCameraDeviceFront];
#else
	return NO;
#endif
}
*/

- (BOOL) canSendEmail
{
	return [MFMailComposeViewController canSendMail];
}

- (BOOL) canSendSMS
{
#ifdef __IPHONE_4_0
	return [MFMessageComposeViewController canSendText];
#else
	return [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"sms://"]];
#endif
}

- (BOOL) canMakePhoneCalls
{
	return [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"tel://"]];
}

- (BOOL) multitaskingCapable
{
	BOOL backgroundSupported = NO;
	if ([self respondsToSelector:@selector(isMultitaskingSupported)])
		backgroundSupported = self.multitaskingCapable;

	return backgroundSupported;
}

- (BOOL) compassAvailable
{
	BOOL compassAvailable = NO;

#ifdef __IPHONE_3_0
	compassAvailable = [CLLocationManager headingAvailable];
#else
	CLLocationManager *cl = [[CLLocationManager alloc] init];
	compassAvailable = cl.headingAvailable;
	[cl release];
#endif

	return compassAvailable;

}

- (BOOL) gyroscopeAvailable
{
#ifdef __IPHONE_4_0
	CMMotionManager *motionManager = [[CMMotionManager alloc] init];
	BOOL gyroAvailable = motionManager.gyroAvailable;
	[motionManager release];
	return gyroAvailable;
#else
	return NO;
#endif

}

- (BOOL) retinaDisplayCapable
{
	int scale = 1.0;
	UIScreen *screen = [UIScreen mainScreen];
	if([screen respondsToSelector:@selector(scale)])
		scale = screen.scale;

	if(scale == 2.0f) return YES;
	else return NO;
}

@end


text:
/*
This file is part of the GSM3 communications library for Arduino
-- Multi-transport communications platform
-- Fully asynchronous
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
-- Voice calls
-- SMS
-- TCP/IP connections
-- HTTP basic clients

This library has been developed by Telefónica Digital - PDI -
- Physical Internet Lab, as part as its collaboration with
Arduino and the Open Hardware Community.

September-December 2012

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

The latest version of this library can always be found at
https://github.com/BlueVia/Official-Arduino
*/
#ifndef _GSM3MOBILENETWORKREGISTRY_
#define _GSM3MOBILENETWORKREGISTRY_
#include <GSM3MobileNetworkProvider.h>

class GSM3MobileNetworkRegistry
{
	private:

		GSM3MobileNetworkProvider* theProvider; // Network provider

	public:

		/** Constructor */
		GSM3MobileNetworkRegistry();

		/** Register in mobile network provider
			@param provider			Provider
		 */
		void registerMobileNetworkProvider(GSM3MobileNetworkProvider* provider);

		/** Returns network provider object pointer
			@return mobile network provider
		 */
		GSM3MobileNetworkProvider* getMobileNetworkProvider();

};

extern GSM3MobileNetworkRegistry theMobileNetworkRegistry;

#endif


text:
package com.nps.micro.view;

import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

import com.nps.micro.R;

/**
 * @author Norbert Pabian
 * www.npsoft.clanteam.com
 */
public class AboutSectionFragment extends BaseSectionFragment {

    private Button settingsButton;

    private AboutFragmentListener listener;

    public void setListener( AboutFragmentListener listener) {
        this.listener = listener;
    }

    public AboutSectionFragment() {
        this.layout = R.layout.about;
    }

    @Override
    protected View buildRootView(LayoutInflater inflater, ViewGroup container) {
        View rootView = inflater.inflate(layout, container, false);

        settingsButton = (Button) rootView.findViewById(R.id.buttonSettings);
        settingsButton.setOnClickListener(new OnClickListener(){
            @Override
            public void onClick(View v) {
                if (listener != null) {
                    listener.openSettings();
                }
            }
        });

        updateStatus(rootView);
        return rootView;
    }
}


text:
@implementation WMProductDetailContentImageTableViewCell

- (void)setProduct:(WMProduct *)product
{
    if (_product != product) {
        _product = product;
    }

    [self updateCell];
}

- (void)updateCell
{
    UIImageView *imageView1 = [[UIImageView alloc] initWithFrame:CGRectMake(0.0f, 0.0f, self.frame.size.width, self.productImagesScrollView.frame.size.height)];
    imageView1.backgroundColor = [UIColor whiteColor];
    imageView1.contentMode = UIViewContentModeScaleAspectFit;

    UIImageView *imageView2 = [[UIImageView alloc] initWithFrame:CGRectMake(self.frame.size.width, 0.0f, self.frame.size.width, self.productImagesScrollView.frame.size.height)];
    imageView2.backgroundColor = [UIColor whiteColor];
    imageView2.contentMode = UIViewContentModeScaleAspectFit;

    UIImageView *imageView3 = [[UIImageView alloc] initWithFrame:CGRectMake(self.frame.size.width*2.0f, 0.0f, self.frame.size.width, self.productImagesScrollView.frame.size.height)];
    imageView3.backgroundColor = [UIColor whiteColor];
    imageView3.contentMode = UIViewContentModeScaleAspectFit;

    self.productImagesScrollView.contentSize = CGSizeMake(self.frame.size.width*3.0f, self.productImagesScrollView.frame.size.height);
    [self.productImagesScrollView addSubview:imageView1];
    [self.productImagesScrollView addSubview:imageView2];
    [self.productImagesScrollView addSubview:imageView3];

    self.productImagesScrollView.pagingEnabled = YES;

    dispatch_async(dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{
        if (!IsEmpty(self.product.productImage)) {
            NSURL *imageURL = [NSURL URLWithString:self.product.productImage];
            NSData *productImage = [NSData dataWithContentsOfURL:imageURL];

            dispatch_async(dispatch_get_main_queue(), ^{
                imageView1.image = [UIImage imageWithData:productImage];
                imageView2.image = [UIImage imageWithData:productImage];
                imageView3.image = [UIImage imageWithData:productImage];
            });
        }
    });
}

- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    CGFloat pageWidth = self.productImagesScrollView.frame.size.width;
    float fractionalPage = self.productImagesScrollView.contentOffset.x / pageWidth;
    NSInteger page = lround(fractionalPage);
    self.pageControl.currentPage = page;
}

@end