chore: fix spelling (#6401)

Signed-off-by: Josh Soref <2119212+jsoref@users.noreply.github.com>
Co-authored-by: Gabor Kiss-Vamosi <kisvegabor@gmail.com>

docs/integration/bindings/micropython.rst

@@ -1,18 +1,18 @@
 .. _micropython:
 
 ===========
-Micropython
+MicroPython
 ===========
 
-What is Micropython?
+What is MicroPython?
 --------------------
 
-`Micropython <http://micropython.org/>`__ is Python for
-microcontrollers. Using Micropython, you can write Python3 code and run
+`MicroPython <http://micropython.org/>`__ is Python for
+microcontrollers. Using MicroPython, you can write Python3 code and run
 it even on a bare metal architecture with limited resources.
 
 
-Highlights of Micropython
+Highlights of MicroPython
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 - **Compact**: Fits and runs within just 256k of code space and 16k of RAM. No OS is needed, although you
@@ -34,25 +34,25 @@ Highlights of Micropython
 --------------
 
 
-Why Micropython + LVGL?
+Why MicroPython + LVGL?
 -----------------------
 
-Micropython `does not have a good native high-level GUI library <https://forum.micropython.org/viewtopic.php?f=18&t=5543>`__.
+MicroPython `does not have a good native high-level GUI library <https://forum.micropython.org/viewtopic.php?f=18&t=5543>`__.
 LVGL is an `Object-Oriented Component Based <https://blog.lvgl.io/2018-12-13/extend-lvgl-objects>`__
 high-level GUI library, which seems to be a natural candidate to map into a higher level language, such as Python.
 LVGL is implemented in C and its APIs are in C.
 
 
-Here are some advantages of using LVGL in Micropython:
+Here are some advantages of using LVGL in MicroPython:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 - Develop GUI in Python, a very popular high level language. Use paradigms such as Object-Oriented Programming.
 - Usually, GUI development requires multiple iterations to get things right. With C, each iteration consists of
-  **``Change code`` > ``Build`` > ``Flash`` > ``Run``**. In Micropython it's just
+  **``Change code`` > ``Build`` > ``Flash`` > ``Run``**. In MicroPython it's just
   **``Change code`` > ``Run``** ! You can even run commands interactively using the
   `REPL <https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>`__ (the interactive prompt)
 
-Micropython + LVGL could be used for:
+MicroPython + LVGL could be used for:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 - Fast prototyping GUI.
@@ -100,20 +100,20 @@ How can I use it?
 Online Simulator
 ~~~~~~~~~~~~~~~~
 
-If you want to experiment with LVGL + Micropython without downloading
+If you want to experiment with LVGL + MicroPython without downloading
 anything - you can use our online simulator! It's a fully functional
-LVGL + Micropython that runs entirely in the browser and allows you to
+LVGL + MicroPython that runs entirely in the browser and allows you to
 edit a python script and run it.
 
 `Click here to experiment on the online simulator <https://sim.lvgl.io/>`__
 
-Many `LVGL examples <https://docs.lvgl.io/master/examples.html>`__ are available also for Micropython. Just click the link!
+Many `LVGL examples <https://docs.lvgl.io/master/examples.html>`__ are available also for MicroPython. Just click the link!
 
 
 PC Simulator
 ~~~~~~~~~~~~
 
-Micropython is ported to many platforms. One notable port is "unix", which allows you to build and run Micropython
+MicroPython is ported to many platforms. One notable port is "unix", which allows you to build and run MicroPython
 (+LVGL) on a Linux machine. (On a Windows machine you might need Virtual Box or WSL or MinGW or Cygwin etc.)
 
 `Click here to know more information about building and running the unix port <https://github.com/lvgl/lv_micropython>`__
@@ -122,13 +122,13 @@ Micropython is ported to many platforms. One notable port is "unix", which allow
 Embedded Platforms
 ~~~~~~~~~~~~~~~~~~
 
-In the end, the goal is to run it all on an embedded platform. Both Micropython and LVGL can be used on many embedded
-architectures. `lv_micropython <https://github.com/lvgl/lv_micropython>`__ is a fork of Micropython+LVGL and currently
-supports Linux, ESP32, STM32 and RP2. It can be ported to any other platform supported by Micropython.
+In the end, the goal is to run it all on an embedded platform. Both MicroPython and LVGL can be used on many embedded
+architectures. `lv_micropython <https://github.com/lvgl/lv_micropython>`__ is a fork of MicroPython+LVGL and currently
+supports Linux, ESP32, STM32 and RP2. It can be ported to any other platform supported by MicroPython.
 
 - You would also need display and input drivers. You can either use one of the existing drivers provided with lv_micropython,
   or you can create your own input/display drivers for your specific hardware.
-- Drivers can be implemented either in C as a Micropython module, or in pure Python!
+- Drivers can be implemented either in C as a MicroPython module, or in pure Python!
 
 lv_micropython already contains these drivers:
 
@@ -165,17 +165,17 @@ Where can I find more information?
 - ``lv_micropython`` `README <https://github.com/lvgl/lv_micropython>`__
 - ``lv_binding_micropython`` `README <https://github.com/lvgl/lv_binding_micropython>`__
 - The `LVGL micropython forum <https://forum.lvgl.io/c/micropython>`__ (Feel free to ask anything!)
-- At Micropython: `docs <http://docs.micropython.org/en/latest/>`__ and `forum <https://forum.micropython.org/>`__
+- At MicroPython: `docs <http://docs.micropython.org/en/latest/>`__ and `forum <https://forum.micropython.org/>`__
 - `Blog Post <https://blog.lvgl.io/2019-02-20/micropython-bindings>`__, a little outdated.
 
 
-The Micropython Binding is auto generated!
+The MicroPython Binding is auto generated!
 ------------------------------------------
 
 - LVGL is a git submodule inside `lv_micropython <https://github.com/lvgl/lv_micropython>`__
   (LVGL is a git submodule of `lv_binding_micropython <https://github.com/lvgl/lv_binding_micropython>`__
   which is itself a submodule of `lv_micropython <https://github.com/lvgl/lv_micropython>`__).
-- When building lv_micropython, the public LVGL C API is scanned and Micropython API is auto-generated. That means that
+- When building lv_micropython, the public LVGL C API is scanned and MicroPython API is auto-generated. That means that
   lv_micropython provides LVGL API for **any** LVGL version, and generally does not require code changes as LVGL evolves.
 
 
@@ -189,7 +189,7 @@ For a summary of coding conventions to follow see the :ref:`coding-style`.
 Memory Management
 ~~~~~~~~~~~~~~~~~
 
-| When LVGL runs in Micropython, all dynamic memory allocations (:cpp:func:`lv_malloc`) are handled by Micropython's memory
+| When LVGL runs in MicroPython, all dynamic memory allocations (:cpp:func:`lv_malloc`) are handled by MicroPython's memory
   manager which is `garbage-collected <https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)>`__ (GC).
 | To prevent GC from collecting memory prematurely, all dynamic allocated RAM must be reachable by GC.
 | GC is aware of most allocations, except from pointers on the `Data Segment <https://en.wikipedia.org/wiki/Data_segment>`__:
@@ -230,18 +230,18 @@ More Information
 Callbacks
 ~~~~~~~~~
 
-In C a callback is just a function pointer. But in Micropython we need to register a *Micropython callable object* for each
-callback. Therefore in the Micropython binding we need to register both a function pointer and a Micropython object for every callback.
+In C a callback is just a function pointer. But in MicroPython we need to register a *MicroPython callable object* for each
+callback. Therefore in the MicroPython binding we need to register both a function pointer and a MicroPython object for every callback.
 
 Therefore we defined a **callback convention** for the LVGL C API that expects lvgl headers to be defined in a certain
-way. Callbacks that are declared according to the convention would allow the binding to register a Micropython object
+way. Callbacks that are declared according to the convention would allow the binding to register a MicroPython object
 next to the function pointer when registering a callback, and access that object when the callback is called.
 
-- The basic idea is that we have ``void * user_data`` field that is used automatically by the Micropython Binding
-  to save the *Micropython callable object* for a callback. This field must be provided when registering the function
+- The basic idea is that we have ``void * user_data`` field that is used automatically by the MicroPython Binding
+  to save the *MicroPython callable object* for a callback. This field must be provided when registering the function
   pointer, and provided to the callback function itself.
-- Although called "user_data", the user is not expected to read/write that field. Instead, the Micropython glue code uses
-  ``user_data`` to automatically keep track of the Micropython callable object. The glue code updates it when the callback
+- Although called "user_data", the user is not expected to read/write that field. Instead, the MicroPython glue code uses
+  ``user_data`` to automatically keep track of the MicroPython callable object. The glue code updates it when the callback
   is registered, and uses it when the callback is called in order to invoke a call to the original callable object.
 
 There are a few options for defining a callback in LVGL C API:

docs/integration/bindings/pikascript.rst

@@ -32,10 +32,10 @@ Why PikaScript + LVGL ?
 -----------------------
 
 PikaScript now supports the main features of LVGL8, and these APIs are
-fully compatible with Micropython!
+fully compatible with MicroPython!
 
 This means that you can continue to use already written code from
-Micropython, and then use less code space and RAM.
+MicroPython, and then use less code space and RAM.
 
 Enjoy detailed code hints down to the parameter type for a better
 programming experience

docs/integration/building/cmake.rst

@@ -9,8 +9,8 @@ Overview
 This project uses CMakePresets to ensure an easy build.  Find out more on Cmake Presets here:
 https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html
 
-Prerequsites
-------------
+Prerequisites
+-------------
 You need to install
 
 - CMake
@@ -46,7 +46,7 @@ When hitting the generate button, CMake will create solution files (for VS) or N
 The following targets are available.
 
 - lvgl (the actual library, required)
-- lvgl_thorvg (an vector grafics extension, optional)
+- lvgl_thorvg (an vector graphics extension, optional)
 - lvgl_examples (example usages, optional)
 - lvgl_demos (some demos, optional)
 
@@ -62,7 +62,7 @@ Build with Command line
 -----------------------
 
 You can also build your project using the command line.
-Run the follwoing commands
+Run the following commands
 
 - cmake --preset windows-base
 - cmake --build --preset windows-base_dbg

docs/integration/chip/nxp.rst

@@ -351,7 +351,7 @@ Supported draw tasks are available in "src/draw/nxp/pxp/lv_draw_vglite.c":
             break;
     }
 
-All the below opration can be done in addition with optional opacity.
+All the below operation can be done in addition with optional opacity.
 - Fill area with color (w/ radius or gradient).
 - Blit source image (any format from `_vglite_src_cf_supported()`) over
   destination (any format from `_vglite_dest_cf_supported()`).

docs/integration/driver/display/gen_mipi.rst

@@ -7,11 +7,11 @@ Overview
 
 From the `Wikipedia <https://en.wikipedia.org/wiki/MIPI_Alliance>`__:
 
-	`MIPI Allience <https://www.mipi.org/>`__ is a global business alliance that develops technical specifications
+	`MIPI Alliance <https://www.mipi.org/>`__ is a global business alliance that develops technical specifications
 	for the mobile ecosystem, particularly smart phones but including mobile-influenced industries. MIPI was founded in 2003 by Arm, Intel, Nokia, Samsung,
 	STMicroelectronics and Texas Instruments.
 
-MIPI Allience published a series of specifications related to display devices, including DBI (Display Bus Interface), DSI (Display Serial Interface) and DCS
+MIPI Alliance published a series of specifications related to display devices, including DBI (Display Bus Interface), DSI (Display Serial Interface) and DCS
 (Display Command Set). Usually when one talks about a MIPI-compatible display, one thinks of a device with a DSI serial interface. However, the Display Bus Interface specification
 includes a number of other, legacy interfaces, like SPI serial, or i8080-compatible parallel interface, which are often used to interface LCD displays to lower-end microcontrollers.
 Furthermore, the DCS specification contains a standard command set, which is supported by a large number of legacy TFT LCD controllers, including the popular Sitronix

docs/integration/driver/display/renesas_glcdc.rst

@@ -50,7 +50,8 @@ The following code demonstrates using the diver in :cpp:enumerator:`LV_DISPLAY_R
     lv_display_set_default(disp);
 
 To use the driver in :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_PARTIAL` mode, an extra buffer must be allocated,
-desirably in the fastest available memory region.
+preferably in the fastest available memory region.
+
 Buffer swapping can be activated by passing a second buffer of same size instead of the :cpp:expr:`NULL` argument.
 
 .. code:: c

docs/integration/framework/tasmota-berry.rst

@@ -52,7 +52,7 @@ also introduced the Berry scripting language, a small-footprint language
 similar to Python and fully integrated in Tasmota.
 
 A comprehensive mapping of LVGL in Berry language is now available,
-similar to the mapping of Micropython. It allows to use +98% of all LVGL
+similar to the mapping of MicroPython. It allows to use +98% of all LVGL
 features. It is also possible to write custom widgets in Berry.
 
 Versions supported: LVGL v8.0.2, LodePNG v20201017, Freetype 2.10.4

docs/integration/ide/pc-simulator.rst

@@ -43,7 +43,7 @@ Built-in drivers
 LVGL comes with several `built-in drivers <https://docs.lvgl.io/master/integration/driver/index.html>`__.
 
 Even if a simulator project comes with e.g. SDL, you can easily replace it by enabling
-an other driver in ``lv_conf.h`` and calling its ``create`` function.
+another driver in ``lv_conf.h`` and calling its ``create`` function.
 
 For example to use the Linux frame buffer device instead of SDL just enable ``LV_USE_LINUX_FBDEV``
 and call