openshot-audio
0.1.2
|
#include <juce_Label.h>
Classes | |
class | Listener |
struct | LookAndFeelMethods |
Public Types | |
enum | ColourIds { backgroundColourId = 0x1000280, textColourId = 0x1000281, outlineColourId = 0x1000282, backgroundWhenEditingColourId = 0x1000283, textWhenEditingColourId = 0x1000284, outlineWhenEditingColourId = 0x1000285 } |
![]() | |
enum | FocusChangeType { focusChangedByMouseClick, focusChangedByTabKey, focusChangedDirectly } |
Additional Inherited Members | |
![]() | |
static Component *JUCE_CALLTYPE | getCurrentlyFocusedComponent () noexcept |
static void JUCE_CALLTYPE | unfocusAllComponents () |
static void JUCE_CALLTYPE | beginDragAutoRepeat (int millisecondsBetweenCallbacks) |
static bool JUCE_CALLTYPE | isMouseButtonDownAnywhere () noexcept |
static int JUCE_CALLTYPE | getNumCurrentlyModalComponents () noexcept |
static Component *JUCE_CALLTYPE | getCurrentlyModalComponent (int index=0) noexcept |
A component that displays a text string, and can optionally become a text editor when clicked.
enum Label::ColourIds |
A set of colour IDs to use to change the colour of various aspects of the label.
These constants can be used either via the Component::setColour(), or LookAndFeel::setColour() methods.
Note that you can also use the constants from TextEditor::ColourIds to change the colour of the text editor that is opened when a label is editable.
Label::Label | ( | const String & | componentName = String::empty , |
const String & | labelText = String::empty |
||
) |
Creates a Label.
componentName | the name to give the component |
labelText | the text to show in the label |
Label::~Label | ( | ) |
Destructor.
void Label::addListener | ( | Listener * | listener | ) |
Registers a listener that will be called when the label's text changes.
void Label::attachToComponent | ( | Component * | owner, |
bool | onLeft | ||
) |
Makes this label "stick to" another component.
This will cause the label to follow another component around, staying either to its left or above it.
owner | the component to follow |
onLeft | if true, the label will stay on the left of its component; if false, it will stay above it. |
|
protected |
|
overrideprotectedvirtual |
This method is called when a colour is changed by the setColour() method.
Reimplemented from Component.
|
overrideprotectedvirtual |
Called when the component's position or size changes.
component | the component that was moved or resized |
wasMoved | true if the component's top-left corner has just moved |
wasResized | true if the component's width or height has just changed |
Reimplemented from ComponentListener.
|
overrideprotectedvirtual |
Called to indicate that the component's parents have changed.
When a component is added or removed from its parent, all of its children will produce this notification (recursively - so all children of its children will also be called as well).
component | the component that this listener is registered with |
Reimplemented from ComponentListener.
|
overrideprotectedvirtual |
Called when the component is made visible or invisible.
component | the component that changed |
Reimplemented from ComponentListener.
|
protectedvirtual |
Creates the TextEditor component that will be used when the user has clicked on the label. Subclasses can override this if they need to customise this component in some way.
Reimplemented in TextPropertyComponent::LabelComp.
|
overrideprotectedvirtual |
Creates a KeyboardFocusTraverser object to use to determine the logic by which focus should be passed from this component.
The default implementation of this method will return a default KeyboardFocusTraverser if this component is a focus container (as determined by the setFocusContainer() method). If the component isn't a focus container, then it will recursively ask its parents for a KeyboardFocusTraverser.
If you overrride this to return a custom KeyboardFocusTraverser, then this component and all its sub-components will use the new object to make their focusing decisions.
The method should return a new object, which the caller is required to delete when no longer needed.
Reimplemented from Component.
|
inlinenoexcept |
Returns true if this option has been set in a call to setEditable().
|
protectedvirtual |
Called when the text editor is going to be deleted, after editing has finished.
|
protectedvirtual |
Called when the text editor has just appeared, due to a user click or other focus change.
|
overrideprotectedvirtual |
Callback to indicate that this component has been enabled or disabled.
This can be triggered by one of the component's parent components being enabled or disabled, as well as changes to the component itself.
The default implementation of this method does nothing; your class may wish to repaint itself or something when this happens.
Reimplemented from Component.
|
overrideprotectedvirtual |
Called to indicate that this component has just acquired the keyboard focus.
Reimplemented from Component.
Component * Label::getAttachedComponent | ( | ) | const |
If this label has been attached to another component using attachToComponent, this returns the other component.
Returns nullptr if the label is not attached.
|
inlinenoexcept |
Returns the size of the border to be left around the text.
|
noexcept |
Returns the currently-visible text editor, or nullptr if none is open.
|
noexcept |
Returns the font currently being used. This may be the one set by setFont(), unless it has been overridden by the current LookAndFeel
|
inlinenoexcept |
Returns the type of justification, as set in setJustificationType().
|
inlinenoexcept |
Specifies the amount that the font can be squashed horizontally.
Returns the label's current text.
returnActiveEditorContents | if this is true and the label is currently being edited, then this method will return the text as it's being shown in the editor. If false, then the value returned here won't be updated until the user has finished typing and pressed the return key. |
|
inlinenoexcept |
Returns the text content as a Value object. You can call Value::referTo() on this object to make the label read and control a Value object that you supply.
void Label::hideEditor | ( | bool | discardCurrentEditorContents | ) |
Hides the editor if it was being shown.
discardCurrentEditorContents | if true, the label's text will be reset to whatever it was before the editor was shown; if false, the current contents of the editor will be used to set the label's text before it is hidden. |
|
overrideprotectedvirtual |
Called when the user tries to click on a component that is blocked by another modal component.
When a component is modal and the user clicks on one of the other components, the modal component will receive this callback.
The default implementation of this method will play a beep, and bring the currently modal component to the front, but it can be overridden to do other tasks.
Reimplemented from Component.
|
inlinenoexcept |
If the label is attached to the left of another component, this returns true.
Returns false if the label is above the other component. This is only relevent if attachToComponent() has been called.
|
noexcept |
Returns true if the editor is currently focused and active.
|
inlinenoexcept |
Returns true if the user can edit this label's text.
|
inlinenoexcept |
Returns true if this option was set using setEditable().
|
inlinenoexcept |
Returns true if this option was set using setEditable().
|
overrideprotectedvirtual |
Called when a mouse button has been double-clicked on a component.
The MouseEvent object passed in contains lots of methods for finding out which button was pressed, as well as which modifier keys (e.g. shift, ctrl) were held down at the time.
event | details about the position and status of the mouse event, including the source component in which it occurred |
Reimplemented from Component.
|
overrideprotectedvirtual |
Called when a mouse button is released.
A mouseUp callback is sent to the component in which a button was pressed even if the mouse is actually over a different component when the button is released.
The MouseEvent object passed in contains lots of methods for finding out which buttons were down just before they were released.
event | details about the position and status of the mouse event, including the source component in which it occurred |
Reimplemented from Component.
|
overrideprotectedvirtual |
Components can override this method to draw their content.
The paint() method gets called when a region of a component needs redrawing, either because the component's repaint() method has been called, or because something has happened on the screen that means a section of a window needs to be redrawn.
Any child components will draw themselves over whatever this method draws. If you need to paint over the top of your child components, you can also implement the paintOverChildren() method to do this.
If you want to cause a component to redraw itself, this is done asynchronously - calling the repaint() method marks a region of the component as "dirty", and the paint() method will automatically be called sometime later, by the message thread, to paint any bits that need refreshing. In Juce (and almost all modern UI frameworks), you never redraw something synchronously.
You should never need to call this method directly - to take a snapshot of the component you could use createComponentSnapshot() or paintEntireComponent().
g | the graphics context that must be used to do the drawing operations. |
Reimplemented from Component.
void Label::removeListener | ( | Listener * | listener | ) |
Deregisters a previously-registered listener.
|
overrideprotectedvirtual |
Called when this component's size has been changed.
A component can implement this method to do things such as laying out its child components when its width or height changes.
The method is called synchronously as a result of the setBounds or setSize methods, so repeatedly changing a components size will repeatedly call its resized method (unlike things like repainting, where multiple calls to repaint are coalesced together).
If the component is a top-level window on the desktop, its size could also be changed by operating-system factors beyond the application's control.
Reimplemented from Component.
void Label::setBorderSize | ( | BorderSize< int > | newBorderSize | ) |
Changes the border that is left between the edge of the component and the text. By default there's a small gap left at the sides of the component to allow for the drawing of the border, but you can change this if necessary.
void Label::setEditable | ( | bool | editOnSingleClick, |
bool | editOnDoubleClick = false , |
||
bool | lossOfFocusDiscardsChanges = false |
||
) |
Makes the label turn into a TextEditor when clicked.
By default this is turned off.
If turned on, then single- or double-clicking will turn the label into an editor. If the user then changes the text, then the ChangeBroadcaster base class will be used to send change messages to any listeners that have registered.
If the user changes the text, the textWasEdited() method will be called afterwards, and subclasses can override this if they need to do anything special.
editOnSingleClick | if true, just clicking once on the label will start editing the text |
editOnDoubleClick | if true, a double-click is needed to start editing |
lossOfFocusDiscardsChanges | if true, clicking somewhere else while the text is being edited will discard any changes; if false, then this will commit the changes. |
Changes the font to use to draw the text.
void Label::setJustificationType | ( | Justification | justification | ) |
Sets the style of justification to be used for positioning the text. (The default is Justification::centredLeft)
|
inlinenoexcept |
Set a keyboard type for use when the text editor is shown.
void Label::setMinimumHorizontalScale | ( | float | newScale | ) |
Specifies the minimum amount that the font can be squashed horizontally before it starts using ellipsis. Use a value of 0 for a default value.
void Label::setText | ( | const String & | newText, |
NotificationType | notification | ||
) |
Changes the label text.
The NotificationType parameter indicates whether to send a change message to any Label::Listener objects if the new text is different.
void Label::showEditor | ( | ) |
Makes the editor appear as if the label had been clicked by the user.
|
overrideprotectedvirtual |
Called when the user presses the escape key.
Reimplemented from TextEditor::Listener.
|
overrideprotectedvirtual |
Called when the text editor loses focus.
Reimplemented from TextEditor::Listener.
|
overrideprotectedvirtual |
Called when the user presses the return key.
Reimplemented from TextEditor::Listener.
|
overrideprotectedvirtual |
Called when the user changes the text in some way.
Reimplemented from TextEditor::Listener.
|
protectedvirtual |
Called when the text has been altered.
|
protectedvirtual |
Called after the user changes the text.
Reimplemented in TextPropertyComponent::LabelComp.
|
overrideprotectedvirtual |
Called when a Value object is changed.
Note that the Value object passed as a parameter may not be exactly the same object that you registered the listener with - it might be a copy that refers to the same underlying ValueSource. To find out, you can call Value::refersToSameSourceAs().
Implements Value::Listener.