Commits

Marcus von Appen  committed 8f3bb84

- minor typo fixes

  • Participants
  • Parent commits 0f59f87

Comments (0)

Files changed (19)

File doc/copying.rst

    This software is distributed under the Public Domain.
 
    In cases, where the law prohibits the recognition of Public Domain
-   software, this software can be licensed under the zlib lincese as
+   software, this software can be licensed under the zlib license as
    stated below:
 
    Copyright (C) 2012-2013 Marcus von Appen <marcus@sysfault.org>
 
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
-      in a product, an acknowledgment in the product documentation would be
+      in a product, an acknowledgement in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.

File doc/modules/sdl2_sdlgfx.rst

 structures and functions of the SDL2_gfx library to be accessible from
 Python code.
 
-A detailled documentation about the behaviour of the different functions
+A detailed documentation about the behaviour of the different functions
 can found on the `SDL2_gfx project website
 <http://www.ferzkopp.net/Software/SDL_gfx-2.0/>`_.

File doc/modules/sdl2_sdlimage.rst

 structures and functions of the SDL2_image library to be accessible from
 Python code.
 
-A detailled documentation about the behaviour of the different functions
+A detailed documentation about the behaviour of the different functions
 can found within the `SDL2_image documentation
 <http://www.libsdl.org/projects/SDL_image/docs/index.html>`_.

File doc/modules/sdl2_sdlmixer.rst

 structures and functions of the SDL2_mixer library to be accessible from
 Python code.
 
-A detailled documentation about the behaviour of the different functions
+A detailed documentation about the behaviour of the different functions
 can found within the `SDL2_mixer documentation
 <http://www.libsdl.org/projects/SDL_mixer/docs/index.html>`_.

File doc/modules/sdl2_sdlttf.rst

 structures and functions of the SDL2_ttf library to be accessible from
 Python code.
 
-A detailled documentation about the behaviour of the different functions
+A detailed documentation about the behaviour of the different functions
 can found within the `SDL2_ttf documentation
 <http://www.libsdl.org/projects/SDL_ttf/docs/index.html>`_.

File doc/modules/sdl2ext_array.rst

     >>> ctview.to_uint16()[3] = 0x6554
     >>> print(text)    aello,Te am a simple ASCII string!"
 
-If the encapsuled object does not provide a (writeable) :func:`buffer`
+If the encapsuled object does not provide a (writable) :func:`buffer`
 interface, but is iterable, the :class:`CTypesView` will create an
 internal copy of the object data using Python's :mod:`array` module and
 perform all operations on that copy. ::

File doc/modules/sdl2ext_color.rst

       100]. Note that this will not return the absolutely exact HSV
       values for the set RGB values in all cases. Due to the RGB mapping
       from 0-255 and the HSV mapping from 0-100 and 0-360 rounding
-      errors may cause the HSV values todiffer slightly from what you
+      errors may cause the HSV values to differ slightly from what you
       might expect.
 
    .. attribute:: i1i2i3
 
    .. method:: normalize() -> (float, float, float, float)
 
-      Returns the normalized RGBA values of the Color as floating point
+      Returns the normalised RGBA values of the Color as floating point
       values in the range [0, 1].
 
    .. method:: __add__(self, color) -> Color
                __div__(self, color) -> Color
                __truediv__(self, color) -> Color
                __mod__(self, color) -> Color
-   
+
       Basic arithmetic functions for :class:`Color` values. The arithmetic
       operations ``+, -, *, /, %`` are supported by the :class:`Color` class
       and work on a per-channel basis. This means, that the operation ::
-      
+
          color = color1 + color2
-      
+
       is the same as ::
-      
+
          color = Color()
          color.r = min(color1.r + color2.r, 255)
          color.g = min(color1.g + color2.g, 255)
          ...
-      
+
       The operations guarantee that the channel values stay in the allowed
       range of [0, 255].
 

File doc/modules/sdl2ext_common.rst

 .. currentmodule:: sdl2.ext
-   
+
 Initialization routines
 =======================
 TODO
 
 .. function:: init() -> None
 
-   Initializes the underlying SDL2 video subsystem. Raises a
+   Initialises the underlying SDL2 video subsystem. Raises a
    :exc:`SDLError`, if the SDL2 video subsystem could not be
    initialised.
 

File doc/modules/sdl2ext_ebs.rst

 it has not, we will do as usual.
 
 Also, checking for the color of an object (regardless, if it is a truck,
-car, airplane or death star) allows us to apply the same or similar
+car, aeroplane or death star) allows us to apply the same or similar
 behaviour for every object. If the information is available, we will
 process it, if it is not, we will not do anything.
 
    on its set :attr:`System.componenttypes`
 
    .. attribute:: is_applicator
-   
+
       A boolean flag indicating that this class operates on combined data sets.
-   
+
    .. attribute:: componenttypes
 
       A tuple of class identifiers that shall be processed by the
 
       Adds a processing system to the world. The system will be
       added as last item in the processing order.
-      
+
       The passed system does not have to inherit from :class:`System`, but
       must feature a ``componenttypes`` attribute and a ``process()`` method,
       which match the signatures of the :class:`System` class ::
-      
+
         class MySystem(object):
             def __init__(self):
                 # componenttypes can be any iterable as long as it
                 # contains the classes the system should take care of
                 self.componenttypes = [AClass, AnotherClass, ...]
-            
+
             def process(self, world, components):
                 ...
 
       If the system shall operate on combined component sets as specified
       by the :class:`Applicator`, the class instance must contain a
       ``is_applicator`` property, that evaluates to ``True`` ::
-      
+
         class MyApplicator(object):
             def __init__(self):
                 self.is_applicator = True
                 self.componenttypes = [...]
-            
+
             def process(self, world, components):
                 pass
-      
+
       The behaviour can be changed at run-time. The ``is_applicator`` attribute
       is evaluated for every call to :meth:`World.process()`.
-      
+
    .. method:: delete(entity : Entity)
 
       Removes an :class:`Entity` from the World, including all its

File doc/modules/sdl2ext_font.rst

 
    Manage fonts and rendering of text.
 
-   One font path must be given to initialize the FontManager.
+   One font path must be given to initialise the FontManager.
    :attr:`default_font` will be set to this font. *size* is the default
    font size in pixels. *color* and *bg_color* will give the FontManager
    a default color.
       not loaded with this size.  A *width* can be given for automatic line
       wrapping.  If no *bg_color* or *color* are given, it will default to
       the FontManager's :attr:`bg_color` and :attr:`color`.
-

File doc/modules/sdl2ext_gui.rst

 to the correct UI element.
 
 Depending on the event type (e.g. pressing a mouse button), the UIProcessor
-will execute its matching method (e.g. ``mousdown()``) with only those UI
+will execute its matching method (e.g. ``mousedown()``) with only those UI
 elements, which support the event type.
 
 .. image:: images/uiprocessing.png

File doc/modules/sdl2ext_particles.rst

             ...
 
    .. method:: process(world : World, components : iterable) -> None
-   
+
       Processes all particle components, decreasing their life by 1.
 
       Once the life of all particle components has been decreased
       argument. ::
 
         def particle_deletefunc(world, list_of_dead_ones):
-            ...   
+            ...
 
 .. class:: Particle(x, y, life : int)
 
    A simple particle component type. It only contains information about
    a x- and y-coordinate and its current life time. The life time will
-   be decreased by 1, everytime the particle is processed by the
+   be decreased by 1, every time the particle is processed by the
    :class:`ParticleEngine`.
 
    .. attribute:: x

File doc/modules/sdl2ext_resources.rst

    be either **"gz"** for gzip compression or **"bz2"** for bzip2
    compression.
 
-   If the filename could not be found or an error occured on reading it,
+   If the filename could not be found or an error occurred on reading it,
    ``None`` will be returned.
 
    Raises a :exc:`TypeError`, if *archive* is not a valid TAR archive or

File doc/modules/sdl2ext_sprite.rst

       Sort function for the component processing order. The default sort order
       is based on the depth attribute of every sprite. Lower depth values will
       cause sprites to be drawn below sprites with higher depth values.  If
-      :attr:`sortfunc` shall be overriden, it must match thre callback
+      :attr:`sortfunc` shall be overridden, it must match the callback
       requirements for :func:`sorted()`.
 
    .. method:: process(world : World, components : iterable) -> None

File doc/modules/sdl2ext_window.rst

 
      Window.DEFAULTPOS = (10, 10)
 
-   The created Window is hidden by default, which can be overriden at
+   The created Window is hidden by default, which can be overridden at
    the time of creation by providing other SDL window flags through the
    *flags* parameter. The default flags for creating Window instances
    can be adjusted through the ``DEFAULTFLAGS`` class variable. ::

File doc/news.rst

 * issue #14: improved the error messages on failing DLL imports
 * issue #19: the :meth:`sdl2.ext.TextureSpriteRenderer.render()` and
   :meth:`sdl2.ext.SoftwareSpriteRenderer.render()` methods do not
-  misinterpret x and y aguments anymore, if set to 0
+  misinterpret x and y arguments anymore, if set to 0
 * issue #21: :func:`sdl2.ext.load_image()` raises a proper
   :exc:`UnsupportedError`, if neither SDL_image nor PIL are usable
 

File doc/tutorial/helloworld.rst

         import traceback
         traceback.print_exc()
         sys.exit(1)
-    
+
     from sdl2.ext import Resources
     RESOURCES = Resources(__file__, "resources")
 
-At first, we try to import the :mod:`sdl2.ext` module, which is 
+At first, we try to import the :mod:`sdl2.ext` module, which is
 necessary for displaying the window and image. :mod:`sdl2.ext` requires
 :mod:`sdl2`, so in case it could not load the SDL2 bindings, we will
 print the exact error stack information and exit with a failure.
 of a window, which basically represents a portion of the screen, the
 application has access to and the application can manipulate. In most cases
 that portion has a border and title bar around it, allowing the user to move
-it around on the screen and reorganize everythingin a way to fit his needs.
+it around on the screen and reorganise everything in a way to fit his needs.
 
 Once we have imported all necessary parts, let's create a window to have
 access to the screen, so we can display the logo and thus represent it
     spriterenderer = factory.create_sprite_renderer(window)
     spriterenderer.render(sprite)
 
-First, we initialize the :mod:`sdl2.ext` internals to gain access to the
+First, we initialise the :mod:`sdl2.ext` internals to gain access to the
 screen and and to be able to create windows on top of it. Once done with that,
 :class:`sdl2.ext.Window` will create the window for us and we
 supply a title to be shown on the window's border along with its initial size.
 everything, once the application finishes. Luckily the
 :class:`sdl2.ext.TestEventProcessor` knows when the window is closed, so
 it will exit from the event loop. Once it exits, we should clean up the
-video internals, we initialized at the beginning. Thus, a final call to ::
+video internals, we initialised at the beginning. Thus, a final call to ::
 
     sdl2ext.quit()
 

File doc/tutorial/pong.rst

 
 The first thing to do is to enhance the
 :class:`sdl2.ext.SoftwareSpriteRenderer` so that it will paint
-the whole window sceeen black on every drawing cycle, before drawing all
+the whole window screen black on every drawing cycle, before drawing all
 sprites on the window.
 
 Afterwards, the player paddles will be implemented, based on an
 
 Moving the ball
 ---------------
-We have two static paddles centered vertically on the left and right of
+We have two static paddles centred vertically on the left and right of
 our window. The next thing to do is to add a ball that can move around
 within the window boundaries. ::
 
 
 Two new classes are introduced here, ``Velocity`` and
 ``MovementSystem``. The ``Velocity`` class is a simple data bag. It
-does not contain any application logic, but consists of the relvant
+does not contain any application logic, but consists of the relevant
 information to represent the movement in a certain direction. This
 allows us to mark in-game items as being able to move around.
 
 ------------------------
 We have a moving ball that bounces from side to side. The next step
 would be to allow moving one of the paddles around, if the player presses a
-key. The SDL event routines allow us to deal with a huge variety of user and 
-ystem events that could occur for our application, but right now we are only
+key. The SDL event routines allow us to deal with a huge variety of user and
+system events that could occur for our application, but right now we are only
 interested in key strokes for the Up and Down keys to move one of the player
 paddles up or down. ::
 
 
 .. rubric:: Footnotes
 
-.. [#f1]  Component-Oriented Programming   
+.. [#f1]  Component-Oriented Programming

File doc/tutorial/pygamers.rst

 pygame.PixelArray
 ^^^^^^^^^^^^^^^^^
 You can access pixel data of sprites and surfaces directly via the
-:class:`sdl2.ext.PixelView` class. It does not feature comparision or
+:class:`sdl2.ext.PixelView` class. It does not feature comparison or
 extractions methods.
 
 pygame.Rect