Show 1 more comment. Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. The Overflow Blog. Podcast Helping communities build their own LTE networks. Podcast Making Agile work for data science. Featured on Meta. New post summary designs on greatest hits now, everywhere else eventually. Visit chat. Krot told the man. Two Crimson Tide coaches are accepting promotions at there big-time programs.
Nelly has now responded. After Inskeep told the ex-president that his fraud claims have repeatedly been proven false, the reporter a. The Alabama coach's Crimson Tide lost to Georgia in the national championship game. It looks like another storm, on Friday, will mostly miss this region. Klay Thompson had a very Klay-like reaction to not getting the ball on an open-look in transition.
Raises the Renamed event. Returns a String containing the name of the Component , if any. This method should not be overridden. A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor. A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor and the time in milliseconds to wait before timing out.
Occurs when a file or directory in the specified Path is changed. Occurs when a file or directory in the specified Path is created. Occurs when a file or directory in the specified Path is deleted. Occurs when the component is disposed by a call to the Dispose method. Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows. Occurs when a file or directory in the specified Path is renamed. Skip to main content.
This browser is no longer supported. Download Microsoft Edge More info. Contents Exit focus mode. Please rate your experience Yes No. Any additional feedback? Namespace: System. IO Assembly: System. ISupportInitialize IDisposable. In this article. Changed , Created , Deleted. FileSystemWatcher String. FileSystemWatcher String, String. Gets a value indicating whether the component can raise an event. Inherited from Component.
Gets or sets the filter string used to determine what files are monitored in a directory. CreateObjRef Type. Both platforms additionally support the Core Data framework, which is as important and useful as the core frameworks. OS X also ships with several other frameworks that publish Cocoa programmatic interfaces, such as the WebKit and Address Book frameworks; more Cocoa frameworks will be added to the operating system over time.
See The Cocoa Frameworks for further information. Architecturally, OS X is a series of software layers going from the foundation of Darwin to the various application frameworks and the user experience they support. The intervening layers represent the system software largely but not entirely contained in the two major umbrella frameworks, Core Services and Application Services. A component at one layer generally has dependencies on the layer beneath it. Figure situates Cocoa in this architectural setting.
For example, the system component that is largely responsible for rendering the Aqua user interface, Quartz implemented in the Core Graphics framework , is part of the Application Services layer. And at the base of the architectural stack is Darwin; everything in OS X, including Cocoa, ultimately depends on Darwin to function. AppKit, one of the application frameworks, provides the objects an application displays in its user interface and defines the structure for application behavior, including event handling and drawing.
This framework, in the Core Services layer, defines the basic behavior of objects, establishes mechanisms for their management, and provides objects for primitive data types, collections, and operating-system services.
Foundation is essentially an object-oriented version of the Core Foundation framework; see Foundation for a discussion of the Foundation framework. AppKit has close, direct dependences on Foundation, which functionally is in the Core Services layer.
If you look closer, at individual, or groups, of Cocoa classes and at particular frameworks, you begin to see where Cocoa either has specific dependencies on other parts of OS X or where it exposes underlying technology with its interfaces.
Some major underlying frameworks on which Cocoa depends or which it exposes through its classes and methods are Core Foundation, Carbon Core, Core Graphics Quartz , and Launch Services:.
Core Foundation. Many classes of the Foundation framework are based on equivalent Core Foundation opaque types. Carbon Core. AppKit and Foundation tap into the Carbon Core framework for some of the system services it provides. For example, Carbon Core has the File Manager, which Cocoa uses for conversions between various file-system representations. Core Graphics. The Cocoa drawing and imaging classes are quite naturally closely based on the Core Graphics framework, which implements Quartz and the window server.
Launch Services. Cocoa also uses the application-registration feature of Launch Services to get the icons associated with applications and documents. Apple has carefully designed Cocoa so that some of its programmatic interfaces give access to the capabilities of underlying technologies that applications typically need.
But if you require some capability that is not exposed through the programmatic interfaces of Cocoa, or if you need some finer control of what happens in your application, you may be able to use an underlying framework directly.
A prime example is Core Graphics; by calling its functions or those of OpenGL, your code can draw more complex and nuanced images than is possible with the Cocoa drawing methods. Fortunately, using these lower-level frameworks is not a problem because the programmatic interfaces of most dependent frameworks are written in standard ANSI C, of which Objective-C language is a superset.
The application-framework layer of iOS is called Cocoa Touch. Compare Figure , which depicts the architectural setting of iOS, to the diagram in Figure The iOS diagram also shows the software supporting its platform as a series of layers going from a Core OS foundation to a set of application frameworks, the most critical for applications being the UIKit framework.
As in the OS X diagram, the iOS diagram has middle layers consisting of core-services frameworks and graphics and media frameworks and libraries. Here also, a component at one layer often has dependencies on the layer beneath it. For example, there is no Carbon application environment in iOS, there is no command-line access the BSD environment in Darwin , there are no printing frameworks and services, and QuickTime is absent from the platform.
However, because of the nature of the devices supported by iOS, there are some frameworks, both public and private, that are specific to iOS. The following summarizes some of the frameworks found at each layer of the iOS stack, starting from the foundation layer. Core OS. This level contains the kernel, the file system, networking infrastructure, security, power management, and a number of device drivers. Core Services. The frameworks in this layer provide core services, such as string manipulation, collection management, networking, URL utilities, contact management, and preferences.
They also provide services based on hardware features of a device, such as the GPS, compass, accelerometer, and gyroscope. This layer includes both Foundation and Core Foundation, frameworks that provide abstractions for common data types such as strings and collections.
The Core Frameworks layer also contains Core Data, a framework for object graph management and object persistence. The frameworks and services in this layer depend on the Core Services layer and provide graphical and multimedia services to the Cocoa Touch layer.
Cocoa Touch. The frameworks in this layer directly support applications based in iOS. These are the core Cocoa frameworks in iOS:. This framework provides the objects an application displays in its user interface and defines the structure for application behavior, including event handling and drawing.
This framework defines the basic behavior of objects, establishes mechanisms for their management, and provides objects for primitive data types, collections, and operating-system services. As with Cocoa in OS X, the programmatic interfaces of Cocoa in iOS give your applications access to the capabilities of underlying technologies. Usually there is a Foundation or UIKit method or function that can tap into a lower-level framework to do what you want.
But, as with Cocoa in OS X, if you require some capability that is not exposed through a Cocoa API, or if you need some finer control of what happens in your application, you may choose to use an underlying framework directly. For example, UIKit uses the WebKit to draw text and publishes some methods for drawing text; however, you may decide to use Core Text to draw text because that gives you the control you need for text layout and font management.
Again, using these lower-level frameworks is not a problem because the programmatic interfaces of most dependent frameworks are written in standard ANSI C, of which the Objective-C language is a superset.
In OS X it is possible to create a Cocoa application without adding a single line of code. You make a new Cocoa application project using Xcode and then build the project. You can move, resize, minimize, and close the window. You can even print the emptiness contained by the window. You can do the same with an iOS application. Create a project in Xcode using one of the project templates, immediately build it, and run it in the iOS Simulator.
The application quits when you click the Home button or press it on a device. To launch the application, click its icon in Simulator. In terms of programming effort, Cocoa gives you, the developer, much that is free and much that is low-cost.
Of course, to become a productive Cocoa developer means becoming familiar with possibly new concepts, design patterns, programming interfaces, and development tools, and this effort is not negligible. But familiarity yields greater productivity. What follows is a short list of how Cocoa adds value to an application with only a little and sometimes no effort on your part:. Basic application framework —Cocoa provides the infrastructure for event-driven behavior and for management of applications, windows, and in the case of OS X workspaces.
Most of these objects are available in the library of Interface Builder, a development application for creating user interfaces; you simply drag an object from the library onto the surface of your interface, configure its attributes, and connect it to other objects. And, of course, you can always instantiate, configure, and connect these objects programmatically.
Here is a sampling of Cocoa user-interface objects:. Cocoa in OS X also features technologies that support user interfaces, including those that promote accessibility, perform validation, and facilitate the connections between objects in the user interface and custom objects.
System interaction —In OS X, Cocoa gives your application ways to interact with and use the services of the file system, the workspace, and other applications.
In iOS, Cocoa lets you pass URLs to applications to have them handle the referenced resource for example, email or websites ; it also provides support for managing user interactions with files in the local system and for scheduling local notifications.
Performance —To enhance the performance of your application, Cocoa provides programmatic support for concurrency, multithreading, lazy loading of resources, memory management, and run-loop manipulation. Internationalization —Cocoa provides a rich architecture for internationalizing applications, making it possible for you to support localized resources such as text, images, and even user interfaces.
It also provides tools and programmatic interfaces for generating and accessing localized strings. Moreover, text manipulation in Cocoa is based on Unicode by default, and is thus an asset for internationalization. Text —In OS X, Cocoa provides a sophisticated text system that allows you to do things with text ranging from the simple for example, displaying a text view with editable text to the more complex, such as controlling kerning and ligatures, spell checking, regular expressions, and embedding images in text.
Although Cocoa in iOS has no native text system it uses WebKit for string drawing and its text capabilities are more limited, it still includes support for spellchecking, regular expressions, and interacting with the text input system. Preferences —The user defaults system is based on a systemwide database in which you can store global and application-specific preferences.
Networking —Cocoa also offers programmatic interfaces for communicating with servers using standard Internet protocols, communicating via sockets, and taking advantage of Bonjour, which lets your application publish and discover services on an IP network. In OS X, Cocoa includes a distributed objects architecture that allows one Cocoa process to communicate with another process on the same computer or on a different one.
In iOS, Cocoa supports the capability for servers to push notifications to devices for applications registered to received such notifications. Printing —Cocoa on both platforms supports printing. Their printing architecture lets you print images, documents, and other application content along a range of control and sophistication.
At the simplest level, you can print the contents of any view or print an image or PDF document with just a little code. At a more complicated level, you can define the content and format of printed content, control how a print job is performed, and do pagination.
In OS X, you can add an accessory view to the Print dialog. Undo management —You can register user actions that occur with an undo manager, and it will take care of undoing them and redoing them when users choose the appropriate menu items.
The manager maintains undo and redo operations on separate stacks. Multimedia —Both platforms programmatically support video and audio. Data exchange —Cocoa simplifies the exchange of data within an application and between applications using the copy-paste model. In OS X, Cocoa also supports drag-and-drop models and the sharing of application capabilities through the Services menu.
Document-based applications —Cocoa specifies an architecture for applications composed of a potentially unlimited number of documents, with each contained in its own window a word processor, for example. Scripting — Through application scriptability information and a suite of supporting Cocoa classes, you can make your application scriptable; that is, it can respond to commands emitted by AppleScript scripts.
Applications can also execute scripts or use individual Apple events to send commands to, and receive data from, other applications. As a result, every scriptable application can supply services to both users and other applications. You develop Cocoa software primarily by using the two developer applications, Xcode and Interface Builder. It is possible to develop Cocoa applications without using these applications at all. For example, you could write code using a text editor such as Emacs, build the application from the command line using makefiles, and debug the application from the command line using the gdb debugger.
But why would you want to give yourself so much grief? The origins of Xcode and Interface Builder coincide with the origins of Cocoa itself, and consequently there is a high degree of compatibility between tools and frameworks.
Together, Xcode and Interface Builder make it extraordinarily easy to design, manage, build, and debug Cocoa software projects. When you install the development tools and documentation, you may select the installation location. Beginning with Xcode 3. The platform SDK contains everything that is required for developing software for a given platform and operating-system release. All SDKs include build settings and project templates appropriate to their platform. Application development differs for OS X and iOS, not only in the tools used but in the development workflow.
Define the targets and executable environment for your project. For iOS development, the workflow when developing an application is a bit more complex. Before you can develop for iOS, you must register as a developer for the platform. This configuration results in the required tools, frameworks, and other components being installed on the device.
Test and debug the application, either in iOS Simulator or remotely in the device. If remotely, your debug executable is downloaded to the device.
It is also an application that takes care of most project details from inception to deployment. It allows you to:. Create and manage projects, including specifying platforms, target requirements, dependencies, and build configurations. Navigate and search through the components of a project, including header files and documentation. It generates executables of all types supported in OS X, including command-line tools, frameworks, plug-ins, kernel extensions, bundles, and applications.
For iOS, only application executables are possible. Xcode permits almost unlimited customization of build and debugging tools, executable packaging including information property lists and localized bundles , build processes including copy-file, script-file, and other build phases , and the user interface including detached and multi-view code editors.
Xcode also supports several source-code management systems—namely CVS, Subversion, and Perforce—allowing you to add files to a repository, commit changes, get updated versions, and compare versions. Xcode is especially suited for Cocoa development. When you create a project, Xcode sets up your initial development environment using project templates corresponding to Cocoa project types: application, document-based application, Core Data application, tool, bundle, framework, and others.
For compiling Cocoa software, Xcode gives you several options:. LLVM offers fast optimization times and high-quality code generation.
Clang offers fast compile times and excellent diagnostics. For details about these compiler options, see Xcode Build System Guide. The Clang Static Analyzer consists of a framework for source-code analysis and a standalone tool that finds bugs in C and Objective-C programs.
Xcode is well integrated with the other major development application, Interface Builder. See Interface Builder for details. The second major development application for Cocoa projects is Interface Builder. As its name suggests, Interface Builder is a graphical tool for creating user interfaces.
Not surprisingly, its integration with Cocoa is airtight. Nib files. A nib file is a file wrapper an opaque directory that contains the objects appearing on a user interface in an archived form.
Essentially, the archive is an object graph that contains information about each object, including its size and location, about the connections between objects, and about proxy references for custom classes. When you create and save a user interface in Interface Builder, all information necessary to re-create the interface is stored in the nib file. Nib files offer a way to easily localize user interfaces.
Interface Builder stores a nib file in a localized directory inside a Cocoa project; when that project is built, the nib file is copied to a corresponding localized directory in the created bundle. Interface Builder presents the contents of a nib file in a nib document window also called a nib file window.
The nib document window gives you access to the important objects in a nib file, especially top-level objects such as windows, menus, and controller objects that have no parent in their object graph. Controller objects mediate between user-interface objects and the model objects that represent application data; they also provide overall management for an application.
Figure shows a nib file opened in Interface Builder and displayed in a nib document window, along with supporting windows.
0コメント