### Linux Processing Installation

Source: https://github.com/processing/processing4/wiki/Legacy-Installation-Instructions-(pre-4.4)

This snippet details the command-line steps to install Processing on a Linux system. It involves extracting a tar.gz archive, navigating to the created directory, and executing the Processing application.

```bash
tar xvfz processing-xxxx.tgz
cd processing-xxxx
./processing
```

--------------------------------

### Processing Library Structure Example

Source: https://github.com/processing/processing4/wiki/Library-Basics

Illustrates the typical file and folder layout for a Processing library, including the main JAR file, supporting JARs, and the essential `library.properties` file.

```text
babel.zip
└── babel/
    ├── library.properties
    ├── library/
    │   ├── babel.jar
    │   └── support.jar
```

--------------------------------

### Interactive Program Startup Notice (GNU GPL)

Source: https://github.com/processing/processing4/blob/main/java/application/launch4j/bin/LICENSE.txt

Example of a short notice to display when a program starts in interactive mode, informing users about its free software status and warranty.

```APIDOC
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
```

--------------------------------

### Examples Package Structure

Source: https://github.com/processing/processing4/wiki/Examples-Overview

Defines the required directory structure for an examples contribution package, which includes an 'examples' directory for sketches and an 'examples.properties' file for metadata.

```text
ExamplesPackage/examples/
ExamplesPackage/examples.properties
```

--------------------------------

### Hosting Example Packages and Properties Files

Source: https://github.com/processing/processing4/wiki/Examples-Overview

Illustrates the recommended server structure for hosting Processing example packages and their corresponding `examples.properties` files. This structure ensures that the Processing website can correctly locate and scrape the necessary information for aggregation.

```text
http://www.example.com/awesomeExamples.zip (The latest version of awesomeExamples)
http://www.example.com/awesomeExamples.txt (A copy of the library.properties file contained in awesomeExamples.zip)
```

--------------------------------

### Processing Tool Properties File Example

Source: https://github.com/processing/processing4/wiki/Tool-Basics

Example of a `tool.properties` file used for advertising a Processing tool. It includes essential attributes for tool identification and compatibility.

```properties
minRevision = 0
maxRevision = 227

imports = org.processing.something,org.processing.something_else

exports = org.processing.awesome,org.processing.something
```

--------------------------------

### tool.properties File Format

Source: https://github.com/processing/processing4/wiki/Tool-Basics

Specifies the attributes required in the `tool.properties` file for a Processing tool, enabling installation and display within the PDE.

```properties
# The name of your tool as you want it formatted.
name = HelloTool

# List of authors. Links can be provided using the syntax [author name](url).
authors = [Your Name](http://yoururl.com)

# A web page for your tool, NOT a direct link to where to download it.
url = http://yourtoolname.com

# The category (or categories) of your tool, must be from the following list:
#   "3D"            "Animation"     "Compilations"      "Data"
#   "Fabrication"   "Geometry"      "GUI"               "Hardware"
#   "I/O"           "Language"      "Math"              "Simulation"
#   "Sound"         "Utilities"     "Typography"        "Video & Vision"
#
# If a value other than those listed is used, your library will listed as
# "Other". Many categories must be comma-separated.
categories = Other

# A short sentence (or fragment) to summarize the tool's function. This will be
# shown from inside the PDE when the tool is being installed. Avoid repeating
# the name of your tool here. Also, avoid saying anything redundant like
# mentioning that it's a tool. This should start with a capitalized letter, and
# end with a period.
sentence = A collection of utilities for solving this and that problem.

# Additional information suitable for the Processing website. The value of
# 'sentence' always will be prepended, so you should start by writing the
# second sentence here. If your tool only works on certain operating systems,
# mention it here.
paragraph = 

# Links in the 'sentence' and 'paragraph' attributes can be inserted using the
# same syntax as for authors.
# That is, [here is a link to Processing](http://processing.org/)

# A version number that increments once with each release. This is used to
# compare different versions of the same tool, and check if an update is
# available. You should think of it as a counter, counting the total number of
# releases you've had.
version = 1  # This must be parsable as an int

# The version as the user will see it. If blank, the version attribute will be
# used here. This should be a single word, with no spaces.
prettyVersion = 0.1.1  # This is treated as a String

# The min and max revision of Processing compatible with your tool.
# Note that these fields use the revision and not the version of Processing,

```

--------------------------------

### Sources.conf Entry Example

Source: https://github.com/processing/processing4/wiki/Mode-Overview

An example of how a mode is listed in the Processing PDE's sources.conf file, providing the URL to the mode's properties file for the Contributions Manager.

```text
["169 \ https://py.processing.org/3/PythonMode.txt"]
```

--------------------------------

### examples.properties File Format

Source: https://github.com/processing/processing4/wiki/Examples-Overview

Details the properties required in the examples.properties file to describe a Processing examples contribution. This includes metadata like name, author, URL, category, version, and compatibility information.

```properties
# The name of your examples-package as you want it formatted.
name = My Processing Examples

# List of authors. Links can be provided using the syntax [author name](url).
authorList = [Author One](http://www.authorone.com/) and [Author Two](http://authortwo.com/)

# A web page for your examples-package, NOT a direct link to where to download it.
url = http://www.myp5examples.com/

# The category of your examples-package, must be one (or many) of the following:
#   "3D"            "Animation"     "Compilations"      "Data"
#   "Fabrication"   "Geometry"      "GUI"               "Hardware"
#   "I/O"           "Language"      "Math"              "Simulation"
#   "Sound"         "Utilities"     "Typography"        "Video & Vision"
#
# If a value other than those listed is used, your examples-package will listed as
# "Other".
category = Geometry

# A short sentence (or fragment) to summarize the examples-package's function. This will
# be shown from inside the PDE when the examples-package is being installed. Avoid
# repeating the name of your examples-package here. Also, avoid saying anything redundant
# like mentioning that it's an examples-package. This should start with a capitalized
# letter, and end with a period.
sentence = A set of sketches demonstrating the creation of complex geometric shapes.

# Additional information suitable for the Processing website. The value of
# 'sentence' always will be prepended, so you should start by writing the
# second sentence here. If your examples-package only works on certain operating systems,
# mention it here.
paragraph = 

# Links in the 'sentence' and 'paragraph' attributes can be inserted using the
# same syntax as for authors.
# That is, [here is a link to Processing](http://processing.org/)

# A version number that increments once with each release. This is used to
# compare different versions of the same examples-package, and check if an update is
# available. You should think of it as a counter, counting the total number of
# releases you've had.
version = 2  # This must be parsable as an int

# The version as the user will see it. If blank, the version attribute will be
# used here.
prettyVersion = 1.20  # This is treated as a String

# The min and max revision of Processing compatible with your examples-package.
# Note that these fields use the revision and not the version of Processing,
# parsable as an int. For example, the revision number for 2.2.1 is 227.
# You can find the revision numbers in the change log:
# https://raw.githubusercontent.com/processing/processing4/master/build/shared/revisions.md
# Only use maxRevision (or minRevision), when your examples-package is known to
# break in a later (or earlier) release. Otherwise, use the default value 0.
minRevision = 0
maxRevision = 227

# The list of modes that the Examples package is compatible with. This basically
# affects when the examples package is listed in the Examples tree once installed
# (although this does not affect when the examples package is displayed/greyed-out
# in the Examples Contributions Manager). This is to be provided as a list of fully
# qualified classnames of the Mode that the Examples package is compatible with
# (as can be obtained from mode.id in the sketch.properties file). Leaving this
# blank will assume that the Examples package is compatible with all Modes.
modes = de.bezier.mode.coffeescript.CoffeeScriptMode, processing.mode.java.JavaMode
```

--------------------------------

### Processing Examples Properties File Structure

Source: https://github.com/processing/processing4/wiki/Examples-Overview

Defines the essential attributes required in the `examples.properties` file for advertising example packages within the Processing Development Environment (PDE). These attributes include metadata about the example package and its author.

```properties
name
authorList
url
category
sentence
version
minRevision
maxRevision
```

--------------------------------

### Install OpenJDK on Ubuntu

Source: https://github.com/processing/processing4/blob/main/build/README.md

Command to install the full version of OpenJDK 17 on Ubuntu, which may be necessary if the default headless version causes issues with Java AWT libraries.

```bash
sudo apt install openjdk-17-jdk
```

--------------------------------

### MSYS2 Package Installation and Environment Setup

Source: https://github.com/processing/processing4/blob/main/build/windows/fenster/README.md

This provides commands for installing necessary packages (gcc, base-devel) within an MSYS2 shell and setting the MSYS2_PATH_TYPE environment variable to inherit the Windows PATH, which is essential for finding Java.

```bash
pacman -Syu
pacman -S base-devel gcc
export MSYS2_PATH_TYPE=inherit
```

--------------------------------

### Examples Window UI Update in Processing

Source: https://github.com/processing/processing4/blob/main/build/shared/revisions.md

Moves the 'Add Examples' button to the bottom of the Examples window for a more intuitive user interface. This change improves the organization and usability of the Examples window.

```Processing
// 'Add Examples' button repositioned in Examples window
```

--------------------------------

### Processing 4 Examples

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/welcome/index.html

This section highlights various examples available in Processing 4, such as mouse interactions, arc tangents, flocking simulations, and 3D rotating arcs. Users are encouraged to run, modify, and explore these examples to learn the Processing language.

```processing
Run the example; watch what happens. Modify the code. Select a keyword and navigate to Help → Find in Reference to learn about it. Open [File → Examples](#examples) for hundreds more.
```

--------------------------------

### library.properties File Format

Source: https://github.com/processing/processing4/wiki/Library-Basics

Defines the structure and required properties for the `library.properties` file, used to describe a Processing library's metadata for installation and display within the IDE.

```properties
# The name of your library as you want it formatted.
name = Most Pixels Ever

# List of authors. Links can be provided using the syntax [author name](url).
authors = [Daniel Shiffman](http://www.shiffman.net/) and Chris Kairalla

# A web page for your library, NOT a direct link to where to download it.
url = http://www.mostpixelsever.com/

# The category (or categories) of your library, must be from the following list:
#   "3D"            "Animation"     "Compilations"      "Data"
#   "Fabrication"   "Geometry"      "GUI"               "Hardware"
#   "I/O"           "Language"      "Math"              "Simulation"
#   "Sound"         "Utilities"     "Typography"        "Video & Vision"
#
# If a value other than those listed is used, your library will listed as
# "Other". Many categories must be comma-separated.
categories = Hardware

# A short sentence (or fragment) to summarize the library's function. This will
# be shown from inside the PDE when the library is being installed. Avoid
# repeating the name of your library here. Also, avoid saying anything redundant
# like mentioning that it's a library. This should start with a capitalized
# letter, and end with a period.
sentence = Framework for spanning Processing sketches across multiple screens.

# Additional information suitable for the Processing website. The value of
# 'sentence' always will be prepended, so you should start by writing the
# second sentence here. If your library only works on certain operating systems,
# mention it here.
paragraph =
```

--------------------------------

### macOS Cross-Compilation Setup with Homebrew

Source: https://github.com/processing/processing4/blob/main/build/windows/fenster/README.md

Instructions for installing mingw-w64 on macOS using Homebrew to facilitate cross-compilation for Windows targets. It notes that this approach was not used due to the necessity of Windows testing.

```bash
brew install mingw-w64
```

--------------------------------

### Processing 4.0 File Bundling (.pdez)

Source: https://github.com/processing/processing4/blob/main/build/shared/revisions.md

Processing 4.0 introduces .pdez files for bundling sketches and libraries. Sketches are saved as .zip files with a .pdez extension for direct loading in the PDE. Libraries, Modes, Tools, and Examples can also be bundled and installed this way.

```Processing
Sketch Bundling:
Save a sketch folder as a .zip file and rename the extension to .pdez.

Library/Mode/Tool Installation:
Bundle Libraries, Modes, Tools, or Examples as .zip files and rename the extension to .pdez. Double-clicking the .pdez file will prompt for installation.
```

--------------------------------

### Running Processing on Linux

Source: https://github.com/processing/processing4/wiki/Supported-Platforms

This command demonstrates how to launch the Processing application from its directory on a Linux system. It's the primary method for starting Processing on Linux.

```shell
./processing
```

--------------------------------

### Processing Library Constructor and Lifecycle

Source: https://github.com/processing/processing4/wiki/Library-Basics

Demonstrates the basic structure of a Processing library, including its constructor which registers a dispose method, and the dispose method itself for cleanup.

```java
package libraryexample;
import processing.core.*;

public class BasicLibrary {
  PApplet parent;

  public BasicLibrary(PApplet parent) {
    this.parent = parent;
    parent.registerMethod("dispose", this);
  }

  public void dispose() {
    // Anything in here will be called automatically when
    // the parent sketch shuts down. For instance, this might
    // shut down a thread used by this library.
  }
}
```

--------------------------------

### Processing Tool Folder Structure

Source: https://github.com/processing/processing4/wiki/Tool-Basics

Defines the standard directory layout for Processing tools, including the placement of the JAR file and source code.

```text
MyTool/tool/MyTool.jar
MyTool/src/
```

--------------------------------

### Processing Application Classes

Source: https://github.com/processing/processing4/wiki/Tool-Basics

Lists key classes within the Processing application that are documented for use in `Tool` classes, providing access to application functionality.

```APIDOC
processing.app.Base:
  Description: The base class for the main Processing application.
  Usage: Provides core application functionalities.

processing.app.ui.Editor:
  Description: Main editor panel for the Processing Development Environment.
  Usage: Interact with the PDE's editor interface. Developers should use caution when accessing/manipulating objects returned by Editor's methods (e.g., JEditTextArea) as they might disrupt existing PDE interface elements or features.

processing.app.Preferences:
  Description: Storage class for user preferences and environment settings.
  Usage: Access and manage user-defined settings.

processing.app.Sketch:
  Description: Stores information about files in the current sketch.
  Usage: Manage sketch-related data.

processing.app.SketchCode:
  Description: Represents a single tab of a sketch.
  Usage: Handle individual sketch files (tabs).
```

--------------------------------

### Distribution File URLs Example

Source: https://github.com/processing/processing4/wiki/Mode-Overview

Illustrates the URLs for a mode's properties file and its downloadable zip archive, as used by the PDE Contributions Manager for distribution and updates.

```text
https://py.processing.org/3/PythonMode.txt
https://py.processing.org/3/PythonMode.zip
```

--------------------------------

### Processing Mouse Event Handling

Source: https://github.com/processing/processing4/wiki/Library-Basics

Example of how to handle different mouse events within the `mouseEvent()` function in Processing. It demonstrates capturing mouse coordinates and reacting to actions like press, release, click, drag, and move.

```java
public void mouseEvent(MouseEvent event) {
  int x = event.getX();
  int y = event.getY();

  switch (event.getAction()) {
    case MouseEvent.PRESS:
      // do something for the mouse being pressed
      break;
    case MouseEvent.RELEASE:
      // do something for mouse released
      break;
    case MouseEvent.CLICK:
      // do something for mouse clicked
      break;
    case MouseEvent.DRAG:
      // do something for mouse dragged
      break;
    case MouseEvent.MOVE:
      // do something for mouse moved
      break;
  }
}
```

--------------------------------

### Mixing Functions and Loose Code in Processing

Source: https://github.com/processing/processing4/wiki/Troubleshooting

Explains that Processing sketches cannot mix standalone code blocks with functions like setup() and draw(). All executable code must either be in functions or in a single block without functions.

```processing
// Invalid structure:
// int x = 10;
// void setup() {
//   size(100, 100);
// }
// void draw() {
//   rect(x, 10, 20, 20);
// }
```

```processing
// Valid structure (all loose code):
// int x = 10;
// println(x);
// // No setup() or draw()

```

```processing
// Valid structure (all in functions):
// int x;
// void setup() {
//   size(100, 100);
//   x = 10;
// }
// void draw() {
//   rect(x, 10, 20, 20);
// }
```

--------------------------------

### Processing: Sketch Naming Conventions

Source: https://github.com/processing/processing4/wiki/Troubleshooting

Processing sketch names have restrictions due to Java class naming rules. Names cannot start with a number or contain spaces. Avoid naming sketches the same as imported libraries or existing classes to prevent conflicts.

```processing
// Valid sketch names: MySketch, Sketch_01, Animation
// Invalid sketch names: 1Sketch, My Sketch
```

--------------------------------

### Processing 3.0: Settings() Method for Initialization

Source: https://github.com/processing/processing4/blob/main/core/README.md

In Processing 3.0, the settings() method is introduced to handle initialization commands like size(), fullScreen(), pixelDensity(), and smooth(). These commands must be called within settings() before setup(). This change aims to simplify the initialization process and improve cross-platform consistency, especially compared to older versions where size() was handled with 'dark magic'.

```processing
void settings() {
  size(800, 600);
  smooth();
}

void setup() {
  // Sketch setup code here
}

void draw() {
  // Drawing code here
}
```

--------------------------------

### Build Processing with Ant

Source: https://github.com/processing/processing4/blob/main/build/README.md

This snippet demonstrates the basic commands to build the Processing IDE using the Ant build system. It includes navigating to the build directory and executing the 'run' target.

```bash
cd /path/to/processing4/build
ant run
```

--------------------------------

### Processing Project Budget

Source: https://github.com/processing/processing4/wiki/Google-Season-of-Docs-2023-(Processing)

Details the proposed budget for the Processing documentation project, including costs for the technical writer, mentor stipends, and community tester honorariums.

```markdown
## Project budget
### General guidelines

Our proposed budget:
| Budget Item                                                           | Amount  | Running Total | Notes |
|-----------------------------------------------------------------------|---------|---------------|-------|
| Technical Writer -  Processing Contributor Docs Organization & Development | $12,500 | $12,500       |The technical writer will audit, update, test, and publish Processing contributor documentation.|
| Mentor Stipends                                                       | $1,000  | $13,500       |       |
| Community Testers Honorarium                                          | $1,500  | $15,000       |10 Community Tester x $150 each ($50 hr x 3 hours)|
| TOTAL                                                                 |         | $15,000       |       |

TOTAL: 15000.00
```

--------------------------------

### Processing: Function Name Capitalization

Source: https://github.com/processing/processing4/wiki/Troubleshooting

Correct capitalization is essential for Processing function names. Built-in functions often follow camelCase, where the first word is lowercase and subsequent words start with an uppercase letter (e.g., `keyPressed`, `movieEvent`). Mismatched capitalization will prevent functions from being called.

```processing
// Correct: mousePressed() will be called on mouse events
// Incorrect: mousepressed() will not be called
```

--------------------------------

### Processing Display Modes on Startup

Source: https://github.com/processing/processing4/blob/main/core/README.md

Lists the different modes in which a Processing sketch can be displayed upon startup, ranging from no display (PDF export) to full-screen and spanning multiple screens.

--------------------------------

### Processing: Improving Transparency with P2D/P3D and Depth Sorting

Source: https://github.com/processing/processing4/wiki/Troubleshooting

In P2D and P3D renderers, transparency (alpha) can be affected by drawing order, potentially making objects appear opaque. Adding `hint(ENABLE_DEPTH_SORT)` in `setup()` can improve rendering by enabling depth sorting, though it may impact performance.

```processing
void setup() {
  size(400, 400, P3D);
  hint(ENABLE_DEPTH_SORT);
}
```

--------------------------------

### Tool Hosting and Update Mechanism

Source: https://github.com/processing/processing4/wiki/Tool-Basics

Explains the server-side requirements for hosting tool files and their corresponding `.properties` files for the Processing IDE's update mechanism.

```APIDOC
Server Hosting Requirements:

  - Provide a static link to the latest version of your tool (e.g., `http://www.example.com/awesometool.zip`).
  - Host a copy of your `tool.properties` file alongside the tool zip, with the `.properties` file renamed to `.txt` (e.g., `http://www.example.com/awesometool.txt`).
  - The Processing website scrapes information from these `.txt` files daily to aggregate tool data for users.
  - Even if not advertised, include `tool.properties` within the tool's zip archive.
```

--------------------------------

### Token Colors Explanation Reference

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/bondoc.txt

Provides a reference to the Token.java file for an explanation of the tags used for source code colors in the editor.

```processing-config
# For an explanation of these tags, see Token.java:
```

--------------------------------

### IntelliJ IDEA CE Setup for Processing

Source: https://github.com/processing/processing4/wiki/Announcing-Processing-4.3.1

Configuration details for setting up a local development environment using IntelliJ IDEA Community Edition for Processing development. This simplifies the process for contributors.

```APIDOC
IntelliJ IDEA CE Setup:

1. Clone the Processing repository.
2. Open the `processing4` directory in IntelliJ IDEA.
3. Configure the project SDK to a compatible Java version.
4. Set up run configurations for testing and development.
5. Refer to the `build/README.md` for detailed instructions.
```

--------------------------------

### IntelliJ IDEA Project Structure Settings

Source: https://github.com/processing/processing4/blob/main/build/README.md

Keyboard shortcuts and navigation steps within IntelliJ IDEA Community Edition to access Project Structure settings, specifically for selecting the JDK.

```APIDOC
IntelliJ IDEA CE Project Setup:

1. Open Project Structure: `Ctrl+Alt+Shift+S` (Windows/Linux) or `⌘;` (macOS)
2. Navigate to: `Project Settings > Project`
3. SDK Dropdown: Select JDK version 17 or choose `Download a JDK`.
```

--------------------------------

### Contributions Manager Install Failure Fix

Source: https://github.com/processing/processing4/blob/main/build/shared/revisions.md

Resolves an issue where the Contributions Manager fails to complete an install when no windows are open.

```Java
/* Manager fails to complete install of PythonMode when no windows open. [#5309](https://github.com/processing/processing/issues/5309), [#446](https://github.com/processing/processing4/issues/446) */
```

--------------------------------

### App Bundler Configuration with Stripped JRE and Modules

Source: https://github.com/processing/processing4/blob/main/build/macos/appbundler/README.md

This example shows how to bundle a stripped-down JRE for a non-modularized application. It uses the `<jlink>` element to specify the runtime path and the required modules (`java.base`, `java.desktop`), along with optional arguments for compression and release information.

```bash
# Obtain path to the selected JRE
      <exec executable="/usr/libexec/java_home"
             failonerror="true"
             outputproperty="runtime">
        <arg value="-v"/>
        <arg value="11"/>
      </exec>
```

```xml
<target name="bundle">
      <!-- Obtain path to the selected JRE -->
      <exec executable="/usr/libexec/java_home"
             failonerror="true"
             outputproperty="runtime">
        <arg value="-v"/>
        <arg value="11"/>
      </exec>

      <taskdef name="bundleapp"
        classpath="appbundler-1.0ea.jar"
        classname="com.oracle.appbundler.AppBundlerTask"/>

        <bundleapp
          classpathref="runclasspathref"
          outputdirectory="${dist}"
          name="${bundle.name}"
          displayname="${bundle.displayname}"
          executableName="MyApp"
          identifier="com.company.product"
          shortversion="${version.public}"
          version="${version.internal}"
          icon="${icons.path}/${bundle.icns}"
          mainclassname="Main"
          copyright="2019 Your Company"
          applicationCategory="public.app-category.finance">

          <jlink runtime="${runtime}">
            <jmod name="java.base"/>
            <jmod name="java.desktop"/>

            <!-- Zip the generated modules file (Optional) -->
            <argument value="--compress=2"/>

            <!-- Preserve all release properties, but update the modules
              -  list. (Optional)
              - 
              -  See https://bugs.openjdk.java.net/browse/JDK-8179563
             -->
            <argument value="--release-info=${runtime}/release"/>
          </jlink>
      </bundleapp>
    </target>
```

--------------------------------

### Clone Processing Repository

Source: https://github.com/processing/processing4/blob/main/build/README.md

Command to clone the Processing IDE source code repository from GitHub.

```bash
git clone https://github.com/processing/processing4.git
```

--------------------------------

### Token Colors Explanation Reference

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/esquel.txt

Provides a reference to the Token.java file for an explanation of the tags used for source code token colors in the editor.

```processing
# For an explanation of these tags, see Token.java: 
```

--------------------------------

### Contributions Manager Python Mode Install Fix

Source: https://github.com/processing/processing4/blob/main/build/shared/revisions.md

Fixes a frequent "Error during download and install of Python Mode for Processing" message in the Contributions Manager.

```Java
/* Fix frequent “Error during download and install of Python Mode for Processing” message. [#5918](https://github.com/processing/processing/issues/5918), [#445](https://github.com/processing/processing4/issues/445) */
```

--------------------------------

### macOS: Installing Xcode Command Line Tools

Source: https://github.com/processing/processing4/wiki/Exporting-Applications

This command installs the necessary Xcode command line tools on macOS, which are required for self-signing applications during the export process in Processing.

```bash
xcode-select --install
```

--------------------------------

### Running Processing PDE with Gradle

Source: https://github.com/processing/processing4/blob/main/BUILD.md

This snippet shows the Gradle command to build and run the Processing PDE. It's the primary method for launching the development environment.

```bash
./gradlew run
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/theme.txt

Specifies the font for the tree elements in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### Token Colors Explanation

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/armanty.txt

Provides a reference to the Token.java file for an explanation of the tags used for token colors in the editor's source code.

```processing
# For an explanation of these tags, see Token.java:
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Minerals/pyrite.txt

Specifies the font for the tree elements in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### Troubleshooting Processing Startup with Debug Log

Source: https://github.com/processing/processing4/wiki/Troubleshooting

This command-line instruction helps generate a debug log for Processing startup issues on Windows. The log file can provide insights into what is happening during the launch process, aiding in diagnosis.

```bash
.\processing.exe --l4j-debug
```

--------------------------------

### Build Processing for Host OS

Source: https://github.com/processing/processing4/blob/main/build/README.md

Navigates to the build directory and executes the 'ant build' command to compile Processing for the current operating system. Results are placed in 'build/{os}/work'.

```shell
cd /path/to/processing4
cd build
ant build
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/imilac.txt

Sets the font for the tree elements in the Examples and Sketchbook windows.

```processing-config
tree.font = processing.sans,plain,12
```

--------------------------------

### Processing Project Timeline

Source: https://github.com/processing/processing4/wiki/Google-Season-of-Docs-2023-(Processing)

Outlines the monthly tasks and milestones for the Processing documentation improvement project over a six-month period.

```markdown
## Timeline
The project itself will take approximately six months to complete, with 250 working hours in total. Once the technical writer is hired, we'll spend a month on technical writer orientation and project mapping, then move onto the audit and friction log, and spend the last few months focusing on improving the documentation.

| Dates          | Action Items                                                                                                                                              |
|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
| May            | Orientation and project mapping with mentor, review the existing contributor documentation                                                              |
| June           | Audit existing documentation, conduct interviews and tests with community testers, create friction log, and identify gaps and areas for improvement.      |
| July - October | Improve the documentation structure, and content based on the friction log                                                                    |
| November       | Project completion. Measure success with community testers, and share project findings presentation (live-presentation or blog-post to Processing Foundation Medium publication and social media) |
```

--------------------------------

### ZoomTreeRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/hoba.txt

Specifies the font for the tree rendering in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/esquel.txt

Sets the font for the tree elements in the Examples and Sketchbook windows.

```processing
## ZoomTreeCellRenderer - tree for Examples and Sketchbook windows ##

tree.font = processing.sans,plain,12
```

--------------------------------

### Mode Properties File Example

Source: https://github.com/processing/processing4/wiki/Mode-Overview

Defines the properties for a Processing Mode, enabling discovery, download, and updates through the PDE Contributions Manager. Includes fields for name, category, authors, URL, description, version, revision restrictions, and dependencies.

```text
name=p5.js Mode
category=Unknown
authors=[Fathom Information Design](http://fathom.info/)
url=https://github.com/fathominfo/processing-p5js-mode
sentence=Adds a simple editor for p5.js code
paragraph=p5jsMode is a simple editor for p5.js
version=16
prettyVersion=1.5.1
minRevision=1280
maxRevision=0
imports=processing.mode.java.JavaMode
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/bacubirito.txt

Specifies the font for tree cells in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### Releasing a New Tool Version

Source: https://github.com/processing/processing4/wiki/Tool-Basics

Details the steps required to release an updated version of a Processing tool, including updating the `tool.properties` file and hosting locations.

```APIDOC
Releasing Tool Updates:

  1. Update `tool.properties` within the tool's zip archive:
     - Increment the `version` attribute (a release counter).
     - Update the `prettyVersion` attribute (a single word, no spaces).
  2. Upload the latest release zip to its static address (e.g., `http://www.example.com/awesometool.zip`).
  3. Upload the updated `tool.properties` file, renamed to `.txt`, to its corresponding static address (e.g., `http://www.example.com/awesometool.txt`).
```

--------------------------------

### Troubleshoot macOS Startup Issues

Source: https://github.com/processing/processing4/wiki/Troubleshooting

Provides steps to diagnose and resolve startup problems on macOS by running Processing from the Terminal. This helps identify error messages that can be reported for further assistance.

```shell
cd /Applications
./Processing.app/Contents/MacOS/Processing
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Minerals/orpiment.txt

Specifies the font for the tree elements displayed in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Minerals/malachite.txt

Specifies the font for tree elements in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Minerals/galena.txt

Sets the font for the tree elements displayed in the Examples and Sketchbook windows.

```processing-config
tree.font = processing.sans,plain,12
```

--------------------------------

### Tool run() Method

Source: https://github.com/processing/processing4/wiki/Tool-Basics

The run() method is invoked when the tool is selected from the menu. It's executed using EventQueue.invokeLater() for safe GUI operations. This method can be called multiple times, so initialization logic should handle repeated calls to prevent issues like creating multiple windows.

```java
public void run()
    // This method will be called by the main application when the tool is selected from the menu. This is called using `EventQueue.invokeLater()`, so that the tool can safely use Swing or any other GUI.
    // Keep in mind that `run()` is called *every time* the tool is selected from the menu. Thus if your sketch is creating a window, a frame or sets up a timer, you need to make sure that you do your initialization only once.
    // If your tool needs to open a window, you may want to use the `Frame` class from the `java.awt` package. The first time `run()` is called you'll create the `Frame` object. Subsequent calls to `run()` should check to see if the `Frame` is still open. If it is, the `Frame` should be brought to the front of the screen. If not, a new `Frame` should be created. This ensures the user won't create superfluous instances of your tool's window(s).
    // You can really do anything in the `run()` method. In lieu of opening a new window, you can use the `statusNotice()` and `statusError()` methods in Editor to let the user know what's happened. See below for a list of Processing classes sanctioned for use in Tool development.
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Minerals/feldspar.txt

Sets the font for the tree component used in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### Mode Download URLs

Source: https://github.com/processing/processing4/wiki/Mode-Overview

Examples of URLs for accessing published Processing mode files. Includes version-specific URLs and a stable 'latest' URL that always points to the most recent release's attachments.

```text
Versioned URL:
https://github.com/foo/mymode/releases/download/v1.0.7/mymode.txt

Latest URL (stable):
https://github.com/foo/mymode/releases/download/latest/mymode.txt
```

--------------------------------

### Distribute Processing for Host OS

Source: https://github.com/processing/processing4/blob/main/build/README.md

Creates a distributable package for the host operating system using the 'ant dist' target. If not already built, Processing will be compiled first.

```shell
cd /path/to/processing4
cd build
ant dist
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Minerals/bauxite.txt

Specifies the font for the tree elements in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/tagish.txt

Specifies the font for the tree renderer used in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### Token Colors Explanation Reference

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/seymchan.txt

Provides a reference to the Token.java file for an explanation of the tags used to define source code colors in the editor.

```processing-config
# For an explanation of these tags, see Token.java:
```

--------------------------------

### Processing Public Roadmap Overview

Source: https://github.com/processing/processing4/wiki/Announcing-Processing-4.3.1

Provides an overview of the public roadmap for Processing development, outlining priorities and plans including CI/CD improvements, Gradle migration, and a new CLI.

```APIDOC
Project: processing/processing4
Feature: Public Roadmap
URL: https://github.com/orgs/processing/projects/32

Description: Outlines priorities and plans for Processing from a technical standpoint.

Key Areas:
- Improved CI/CD
- Full migration to Gradle
- New Command Line Interface (CLI)
- Future directions for the PDE

Interaction:
- Users can ask questions in corresponding GitHub issues for roadmap items.
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/seymchan.txt

Sets the font for the tree elements displayed in the Examples and Sketchbook windows.

```processing-config
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/omolon.txt

Sets the font for the tree elements in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### Generate JNLP Launcher and Sign Application

Source: https://github.com/processing/processing4/blob/main/build/macos/appbundler/doc/appbundler.html

This example shows how to generate a JNLP launcher, package it, and sign the application using the AppBundlerTask and codesign. It includes creating directories, configuring the bundle with JNLP specific details, copying the JNLP file, and signing the application bundle on macOS.

```ant
<taskdef name="bundleapp" classname="com.oracle.appbundler.AppBundlerTask"/>
<target name="bundle-swingset" depends="package">
    <mkdir dir="./app">
    <bundleapp outputdirectory="./app"
        name="SwingSet2"
        displayname="SwingSet 2"
        identifier="com.oracle.javax.swing.SwingSet2"
        shortversion="1.0"
        icon="icon.icns"
        applicationCategory="public.app-category.developer-tools"
        jnlplaunchername="Contents/_CodeSignature/SwingSet2.jnlp">
        <value="-Xdock:icon=Contents/Resources/icon.icns" />
        <option value="-Dapple.laf.useScreenMenuBar=true"/>
    </bundleapp>
    <copy todir="./SwingSet2.app/Contents/_CodeSignature" includeemptydirs="true" overwrite="false">
        <fileset dir=".">
            <include name="**/ *.jnlp" />
        </fileset>
    </copy>
    <exec executable="codesign" os="Mac OS X" failonerror="true">
        <arg value="-f" />
        <arg value="--deep" />
        <arg value="-s" />
        <arg value="Developer ID Application" />
        <arg value="./app/SwingSet2.app" />
    </exec>
    <zip destfile="./SwingSet2.app.zip" basedir="${copyroot}/app"></zip>
</target>
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/jepara.txt

Specifies the font for the tree elements used in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/gancedo.txt

Specifies the font for the tree elements in the Examples and Sketchbook windows.

```processing
tree.font = processing.sans,plain,12
```

--------------------------------

### ZoomTreeCellRenderer Font

Source: https://github.com/processing/processing4/blob/main/build/shared/lib/theme/Alloys/brahin.txt

Sets the font for the tree cells used in the Examples and Sketchbook windows.

```processing-config
tree.font = processing.sans,plain,12
```