The demo project displays some child components and performs some simple drawing commands, which are used to illustrate how colours are specified and applied to components in JUCE. The application should look similar to the following screenshot:
Creating a color array with distinct colors
I’m trying to create an array which includes separate distinct colors. Color array will created automatically when the range ‘n’ given. It’s something as following:
variable n = 2; colourarrray = [red,green]; variable n = 4; colourarrray = [red,green,blue,yellow]; What is the easiest method to generate such a color array?
Follow
1,613 14 14 silver badges 26 26 bronze badges
asked Oct 2, 2013 at 14:09
nrnw nrnw
461 6 6 silver badges 13 13 bronze badges
Where is your Java code?
– user1907906
Oct 2, 2013 at 14:10
You might create a color spectrum using a LinearGradientPaint as seen in this answer. Then you could get the relevant color using a loop and incrementing the x value used to get the corresponding color in the gradient.
Oct 2, 2013 at 14:19
2 Answers 2
Sorted by: Reset to default
An enum. Because it is scalable.
public enum Colors < BLACK(255, 255, 255), WHITE(0, 0, 0); private int red; private int green; private int blue; private Colors(final int red, final int green, final int blue) < this.red = red; this.green = green; this.blue = blue; >public int red() < return red; >public int green() < return green; >public int blue() < return blue; >> Then dinamically add them to a List as you need them.
Follow
answered Oct 2, 2013 at 14:21
Georgian Georgian
8,835 8 8 gold badges 47 47 silver badges 88 88 bronze badges
Since you didn’t put any specification, additional infos or anything to your question and I have nothing better to do right now:
private java.util.Random rnd = new java.util.Random(); public java.awt.Color[] getColors(int num) < java.util.Listcolors = new java.util.ArrayList<>(num); int i = 0; while (i++ < num) < colors.add(new java.awt.Color(rnd.nextInt(255), rnd.nextInt(255), rnd.nextInt(255), 100)); >java.awt.Color[] array = colors.toArray(new java.awt.Color[num]); return array; >
Colours and general painting operations
JUCE specifies colours using red, green, blue, and alpha (transparency) values. This is, of course, a widely used method of specificy colours in computing, but all implementations are slightly different. In particular, JUCE provides some useful methods for manipulating colours, which can help you maintain a consistent colour palette for your application. First, let’s look at the paint() function from the demo application:
void paint (juce::Graphics& g) override
g.fillAll (juce::Colours::lightgreen);
g.setColour (juce::Colours::orange);
auto centralArea = getLocalBounds().toFloat().reduced (10.0f);
g.drawRoundedRectangle (centralArea, 5.0f, 3.0f);
juce::Array
auto colourBarArea = centralArea.reduced (4.0f).withHeight (20.0f);
auto colourArea = colourBarArea.withWidth (colourBarArea.getWidth() / ( float ) colours.size());
for ( auto colour : colours)
g.setColour (colour);
g.fillRect (colourArea);
colourArea.translate (colourArea.getWidth(), 0.0f);
The first line fills the entire graphics context with a single colour (which means the entire component’s bounds):
g.fillAll (juce::Colours::lightgreen);
The next line sets the colour for future drawing operations for a given graphics context.
g.setColour (juce::Colours::orange);
Then we define a slightly inset rectangle and draw a rounded rectangle, as a border, using the current colour:
auto centralArea = getLocalBounds().toFloat().reduced (10.0f);
g.drawRoundedRectangle (centralArea, 5.0f, 3.0f);
Next, we set up an array of colours, which we will use to draw a row of different coloured rectangles.
juce::Array
To draw this row of coloured rectangles, we first define the area within which they will be placed:
auto colourBarArea = centralArea.reduced (4.0f).withHeight (20.0f);
Then we define the area for the first coloured rectangle. This will be a proportion of the total width of the colourBarArea rectangle, divided by the number of colours that we are using:
auto colourArea = colourBarArea.withWidth (colourBarArea.getWidth() / colours.size());
Finally, we iterate over the array of colours, fill the rectangle with the specified colour, and move the colourArea rectangle to the right for the next iteration:
for ( auto colour : colours)
g.setColour (colour);
g.fillRect (colourArea);
colourArea.translate (colourArea.getWidth(), 0.0f);
In the next few examples we will demonstrate some methods for specifying colours by changing the colours added to the colours array.
Specifying colours by name
As shown in the demo project and the code above, colours can be specified in JUCE using some constants in the Colours namespace.
Note Have a look at the API documentation for the Colours namespace for a full list, which are mostly standard HTML colours.
In addition to the constants within the Colours namespace, you can use the Colours::findColourForName() function, using a string to look up the desired colour name. For example, we could use the same red, green, and blue colours using the following code to fill our colours array:
auto defaultColour = Colours::black;
juce::Array
juce::Colours::findColourForName ( “green” , defaultColour),
juce::Colours::findColourForName ( “blue” , defaultColour) >;
const Colour black
Definition juce_Colours.h:49
Note We need to provide a default colour (in this case we just use black) just in case the search for the named colour fails.
The Colours::findColourForName() function performs a case-insensitive search and trims whitespace from the start and end of the string, but not spaces within the string. For example, the following code will still work as expected, even though the colours are stored internally using all lowercase strings:
auto defaultColour = juce::Colours::black;
juce::Array
juce::Colours::findColourForName ( “DarkGreen” , defaultColour),
juce::Colours::findColourForName ( “DarkBlue” , defaultColour) >;
This produces the following colours:
Dark red, green, and blue
But including spaces within the colour name will fail, in our case returning a black colour in each case:
auto defaultColour = Colours::black;
juce::Array
juce::Colours::findColourForName ( “Dark Green” , defaultColour),
juce::Colours::findColourForName ( “Dark Blue” , defaultColour) >;
It is straightforward to write your own functions to suit your needs in these instances. For example, you could write a function to remove all spaces from a string:
static juce::String removeSpaces ( const juce::String& text)
return text.removeCharacters ( ” ” );
And use that when passing a string to the Colours::findColourForName() function:
auto defaultColour = juce::Colours::black;
juce::Array
juce::Colours::findColourForName (removeSpaces ( “Dark Green” ), defaultColour),
juce::Colours::findColourForName (removeSpaces ( “Dark Blue” ), defaultColour) >;
Specifying colours from values
Colours can also be specified using the raw red, green, blue, and alpha values. Here you can create a Colour object using either floating point values in the range 0.0-1.0, or integers (of type uint8) between 0-255. Using integers we can create the same red, green, and blue colours as follows:
juce::Array
juce::Colour (0, 128, 0), // green
juce::Colour (0, 0, 255) >; // blue
Note The standard “green” colour does not have the maximum value 255 in the green element of the colour.
Omitting the alpha value in this case sets the alpha value to the maximum (255) making the colour completely opaque.
We can also use a single hexadecimal value to specify a colour. In this case the order of the colour value elements is: alpha, red, green, and blue:
juce::Array
juce::Colour (0xff008000), // green
juce::Colour (0xff0000ff) >; // blue
Note In this case we MUST specify the alpha value otherwise it will be set to zero (and therefore transparent).
We can also use floating point values using the Colour::fromFloatRGBA() function:
juce::Array
juce::Colour::fromFloatRGBA (0.0f, 0.5f, 0.0f, 1.0f), // green
juce::Colour::fromFloatRGBA (0.0f, 0.0f, 1.0f, 1.0f) >; // blue
Note A integer value of 128 is equivalent to a floating point value of around 0.501961. Therefore the green colours is not quite the same as the previous example, but 0.5 is close enough for this demonstration. Exercise Try out different colour values and review the results by running the application. You are not limited to adding three colours to the colours array, you can use any number of colours (greater than or equal to one).
