Commits

Ronald Oussoren committed 0c821d1

Fixes a number of dead links in the documentation

There are some dead links left to Apple's documentation site,
in particular for sample code.

  • Participants
  • Parent commits 922c9da

Comments (0)

Files changed (6)

File pyobjc-core/Doc/dev/coding-style.rst

 Coding style for PyObjC 
 =======================
 
-:authors: Ronald Oussoren,
-          Bill Bumgarner
-:contact: pyobjc-dev@lists.sourceforge.net
-:URL: http://pyobjc.sourceforge.net/
-:copyright: 2002 The PyObjC Project
-
 Introduction
 ------------
 

File pyobjc-core/Doc/intro.rst

 
 * `The Objective-C Programming Language`_ at `Apple`_.
 
-.. _`The Objective-C Programming Language`: http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/index.html
+.. _`The Objective-C Programming Language`: https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/Introduction.html
+
+   The link is not correct, but the actual document is not online at the  moment.
 
 
 Overview of the bridge
 in the documentation (`Notes on supported APIs and classes on Mac OS X`_ for
 Cocoa on Mac OS X).
 
-.. _`Notes on supported APIs and classes on Mac OS X`: api-notes-macosx.html
+.. _`Notes on supported APIs and classes on Mac OS X`: :doc:`/apinotes`
 
 Most methods or functions that take or return pointers to values will be an
 exception to this rule if it is callable from Python at all.  In Objective-C
 Reference counting
 ..................
 
-The `Cocoa libraries`_, and most (if not all) other class libraries for 
+The Cocoa libraries, and most (if not all) other class libraries for 
 Objective-C use explicit reference counting to manage memory.  The methods
 ``retain``, ``release`` and ``autorelease`` are used to manage these 
 reference counts.  You won't have to manage reference counts in Python, the
-bridge does all that work for you (but see `Notes on supported APIs and classes 
-on Mac OS X`__ for some advanced issues).
-
-.. __: api-notes-macosx.html
+bridge does all that work for you (but see :doc:`Notes on supported APIs and classes 
+on Mac OS X </apinotes>` for some advanced issues).
 
 The only reasons reference counts are mentioned at all are to tell you about
 ignoring them, and more importantly to introduce you to some issues w.r.t. 
 objects to add the right method signatures to methods, and to warn about
 classes that partially implement a protocol.
 
-See `PyObjC protocol support`__ for more information.
-
-.. __: protocols.html
+See :doc:`PyObjC protocol support <protocols>` for more information.
 
 Cocoa Bindings
 ..............
 information.
 
 PyObjC includes a number of examples that show how to use Cocoa from
-Python.  The `PyObjC Example index`_ contains an overview of those examples.
+Python.  The :doc:`PyObjC Example index </examples/index>` contains an overview of those examples.
 
 More information on Cocoa programming can be found at:
 
 
 * Your local bookstore or library
 
-.. _`PyObjC Example index`: ../Examples/00ReadMe.html
+.. :doc:`PyObjC Example index </examples/index>`:
 
 ..  _`Cocoa libraries`: https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CocoaFundamentals/Introduction/Introduction.html#//apple_ref/doc/uid/TP40002974
 
 you ran setup.py with.
 
 For more information about ``py2app`` usage, read through some of the
-``setup.py`` scripts used by the examples in the `Examples`__ folder.
+``setup.py`` scripts used by the examples in the :doc:`Examples </examples/index>` folder.
 On any ``setup.py`` script that imports ``py2app``, you can use the
 following command to see the list of options:
 
 
     $ python setup.py py2app --help
 
-.. __: ../Examples/00ReadMe.txt
 
 
-"IDE approach" : Xcode
-......................
+.. 
+        This section is disabled for now because the Xcode templates aren't maintained.
 
-PyObjC includes a number of Xcode templates that can be used to 
-develop applications, using the same underlying functionality that
-is in py2app.  These templates are used like any other Xcode template,
-but there are some organizational rules about the template.
+        "IDE approach" : Xcode
+        ......................
 
-See `the documentation for the templates`__ for more details.
+        PyObjC includes a number of Xcode templates that can be used to 
+        develop applications, using the same underlying functionality that
+        is in py2app.  These templates are used like any other Xcode template,
+        but there are some organizational rules about the template.
 
-.. __: Xcode-Templates.html
+        See `the documentation for the templates` for more details.
+
+        .. Xcode-Templates.html

File pyobjc-core/Doc/metadata/manual.rst

 * *arguments*: A dictionary containing more information on arguments. The keys of this dictionary are integers
   with the argument offset (for methods index 0 is the first implicit argument, index 2 is the first argument that is
   visible in a prototype). The values are metadata dictionaries for the arguments and are decribed 
-  `later on <argument and return value metadata>`_.
+  `later on <Argument and return value metadata>`_.
 
   In metadata that is returned the *__metadata__()* method of :class:`function` and :class:`selector` objects the
   *arguments* value is a tuple with items for all arguments.
 
 
 * *retval*: A metadata dictionary with more information on the return value. The contents of this dictionary
-  is described `later on <argument and return value metadata>`_.
+  is described `later on <Argument and return value metadata>`_.
 
 * *suggestion*: For methods only: the method should not be called from Python, and calling it will raise and exception
   with the *suggestion* value in the exception message.

File pyobjc-core/Doc/tutorials/intro.rst

 marketing-speak: Cocoa is inherently different from common toolkits such as
 Tk, wxWindows, Carbon, MFC, etc.  Apple's documentation explains this, but
 such introductory text is often skipped.  It is a good idea to refer back to
-`Application Architecture`__ after reading this section.  If you want, you can
+`The Core App Design`__ after reading this section.  If you want, you can
 write code that does not follow the Model-View-Controller paradigm, but you
 would be on your own.  Cocoa and Interface Builder are designed to suit this
 model.
 
-.. __: http://developer.apple.com/documentation/Cocoa/Conceptual/AppArchitecture/index.html
+.. __: https://developer.apple.com/library/mac/#documentation/General/Conceptual/MOSXAppProgrammingGuide/Introduction/Introduction.html
 
 Cocoa is built on the Model-View-Controller paradigm (MVC).  What this means
 is that the application code should be split into three parts:

File pyobjc-core/NEWS.txt

     such as an ``NSArray``, and there are no direct references to the block from
     Python.
 
-.. __: http://clang.llvm.org/docs/Block-ABI-Apple.txt
+.. __: https://llvm.org/viewvc/llvm-project/cfe/trunk/docs/Block-ABI-Apple.txt?revision=HEAD
 
 - ``objc.inject`` is no longer support. This was code that had no real relation
   to the rest of PyObjC and was only working in 32-bit mode with little reason

File pyobjc-framework-Cocoa/Examples/AppKit/CocoaBindings/CurrencyConvBinding/summary.txt

 
 .. __: ../../CurrentConverter/index.html
 
-Originally from `Introduction to Developing Cocoa Applications Using Bindings`__, converted to PyObjC by u.fiedler.
+Originally from `Introduction to Developing Cocoa Applications Using Bindings`, converted to PyObjC by u.fiedler.
 
-.. __: http://developer.apple.com/documentation/Cocoa/Conceptual/CurrencyConverterBindings/index.html
+.. http://developer.apple.com/documentation/Cocoa/Conceptual/CurrencyConverterBindings/index.html
+
+   NOTE: The link above is dead