Rectangle<int> PaintElement::getCurrentAbsoluteBounds() const
{
jassert (dynamic_cast<PaintRoutineEditor*> (getParentComponent()) != nullptr);
const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());
return position.getRectangle (area, getDocument()->getComponentLayout());
}
void PaintElement::getCurrentAbsoluteBoundsDouble (double& x, double& y, double& w, double& h) const
{
jassert (dynamic_cast<PaintRoutineEditor*> (getParentComponent()) != nullptr);
const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());
position.getRectangleDouble (x, y, w, h, area, getDocument()->getComponentLayout());
}
void EditingPanelBase::visibilityChanged()
{
if (isVisible())
{
updatePropertiesList();
if (Component* p = getParentComponent())
{
resized();
if (JucerDocumentEditor* const cdh = dynamic_cast<JucerDocumentEditor*> (p->getParentComponent()))
cdh->setViewportToLastPos (viewport, *this);
resized();
}
}
else
{
if (Component* p = getParentComponent())
if (JucerDocumentEditor* const cdh = dynamic_cast<JucerDocumentEditor*> (p->getParentComponent()))
cdh->storeLastViewportPos (viewport, *this);
}
editor->setVisible (isVisible());
}
void mouseUp (const MouseEvent& e)
{
if (e.originalComponent != this)
{
if (mouseDragSource != nullptr)
mouseDragSource->removeMouseListener (this);
// (note: use a local copy of this in case the callback runs
// a modal loop and deletes this object before the method completes)
DragAndDropTarget::SourceDetails details (sourceDetails);
DragAndDropTarget* finalTarget = nullptr;
const bool wasVisible = isVisible();
setVisible (false);
Component* unused;
finalTarget = findTarget (e.getScreenPosition(), details.localPosition, unused);
if (wasVisible) // fade the component and remove it - it'll be deleted later by the timer callback
dismissWithAnimation (finalTarget == nullptr);
if (getParentComponent() != nullptr)
getParentComponent()->removeChildComponent (this);
if (finalTarget != nullptr)
{
currentlyOverComp = nullptr;
finalTarget->itemDropped (details);
}
// careful - this object could now be deleted..
}
}
//==============================================================================
void TopLevelWindow::centreAroundComponent (Component* c, const int width, const int height)
{
if (c == nullptr)
c = TopLevelWindow::getActiveTopLevelWindow();
if (c == nullptr || c->getBounds().isEmpty())
{
centreWithSize (width, height);
}
else
{
Point<int> targetCentre (c->localPointToGlobal (c->getLocalBounds().getCentre()));
Rectangle<int> parentArea (c->getParentMonitorArea());
if (getParentComponent() != nullptr)
{
targetCentre = getParentComponent()->getLocalPoint (nullptr, targetCentre);
parentArea = getParentComponent()->getLocalBounds();
}
parentArea.reduce (12, 12);
setBounds (jlimit (parentArea.getX(), jmax (parentArea.getX(), parentArea.getRight() - width), targetCentre.getX() - width / 2),
jlimit (parentArea.getY(), jmax (parentArea.getY(), parentArea.getBottom() - height), targetCentre.getY() - height / 2),
width, height);
}
}
void EnvelopeHandleComponent::mouseUp(const MouseEvent& e)
{
(void)e;
EnvelopeComponent *env = getParentComponent();
#ifdef MYDEBUG
printf("MyEnvelopeHandleComponent::mouseUp\n");
#endif
if(ignoreDrag == true)
{
ignoreDrag = false;
goto exit;
}
// if(e.mods.isCtrlDown() == false)
// {
env->quantiseHandle(this);
// }
setMouseCursor(MouseCursor::CrosshairCursor);
setMousePositionToThisHandle();
offsetX = 0;
offsetY = 0;
exit:
getParentComponent()->sendEndDrag();
}
void paint (Graphics& g) override
{
jassert (dynamic_cast <CodeEditorComponent*> (getParentComponent()) != nullptr);
const CodeEditorComponent& editor = *static_cast <CodeEditorComponent*> (getParentComponent());
g.fillAll (editor.findColour (CodeEditorComponent::backgroundColourId)
.overlaidWith (editor.findColour (lineNumberBackgroundId)));
const Rectangle<int> clip (g.getClipBounds());
const int lineH = editor.lineHeight;
const float lineHeightFloat = (float) lineH;
const int firstLineToDraw = jmax (0, clip.getY() / lineH);
const int lastLineToDraw = jmin (editor.lines.size(), clip.getBottom() / lineH + 1,
lastNumLines - editor.firstLineOnScreen);
const Font lineNumberFont (editor.getFont().withHeight (jmin (13.0f, lineHeightFloat * 0.8f)));
const float w = getWidth() - 2.0f;
GlyphArrangement ga;
for (int i = firstLineToDraw; i < lastLineToDraw; ++i)
ga.addFittedText (lineNumberFont, String (editor.firstLineOnScreen + i + 1),
0, (float) (lineH * i), w, lineHeightFloat,
Justification::centredRight, 1, 0.2f);
g.setColour (editor.findColour (lineNumberTextId));
ga.draw (g);
}
//==============================================================================
void ColouredElement::createSiblingComponents()
{
{
GradientPointComponent* g1 = new GradientPointComponent (this, false, true);
siblingComponents.add (g1);
GradientPointComponent* g2 = new GradientPointComponent (this, false, false);
siblingComponents.add (g2);
getParentComponent()->addAndMakeVisible (g1);
getParentComponent()->addAndMakeVisible (g2);
g1->updatePosition();
g2->updatePosition();
}
if (isStrokePresent && showOutline)
{
GradientPointComponent* g1 = new GradientPointComponent (this, true, true);
siblingComponents.add (g1);
GradientPointComponent* g2 = new GradientPointComponent (this, true, false);
siblingComponents.add (g2);
getParentComponent()->addAndMakeVisible (g1);
getParentComponent()->addAndMakeVisible (g2);
g1->updatePosition();
g2->updatePosition();
}
}
//=================================================================================================
void ClipsContainer::mouseDown (const MouseEvent& event)
{
if (event.mouseWasClicked() && event.mods.isLeftButtonDown())
controller->deselectAll();
if (getParentComponent() != nullptr)
getParentComponent()->mouseDown(event);
}
void setNewScreenPos (const Point<int>& screenPos)
{
Point<int> newPos (screenPos - imageOffset);
if (getParentComponent() != nullptr)
newPos = getParentComponent()->getLocalPoint (nullptr, newPos);
setTopLeftPosition (newPos);
}
void EnvelopeHandleComponent::recalculatePosition()
{
bool oldDontUpdateTimeAndValue = dontUpdateTimeAndValue;
dontUpdateTimeAndValue = true;
setTopLeftPosition(getParentComponent()->convertDomainToPixels(time),
getParentComponent()->convertValueToPixels(value));
dontUpdateTimeAndValue = oldDontUpdateTimeAndValue;
getParentComponent()->repaint();
}
void mouseUp (const MouseEvent& e)
{
if (e.originalComponent != this)
{
if (mouseDragSource != nullptr)
mouseDragSource->removeMouseListener (this);
bool dropAccepted = false;
DragAndDropTarget* ddt = nullptr;
Point<int> relPos;
if (isVisible())
{
setVisible (false);
ddt = findTarget (e.getScreenPosition(), relPos);
// fade this component and remove it - it'll be deleted later by the timer callback
dropAccepted = ddt != nullptr;
setVisible (true);
if (dropAccepted || sourceDetails.sourceComponent == nullptr)
{
Desktop::getInstance().getAnimator().fadeOut (this, 120);
}
else
{
const Point<int> target (sourceDetails.sourceComponent->localPointToGlobal (sourceDetails.sourceComponent->getLocalBounds().getCentre()));
const Point<int> ourCentre (localPointToGlobal (getLocalBounds().getCentre()));
Desktop::getInstance().getAnimator().animateComponent (this,
getBounds() + (target - ourCentre),
0.0f, 120,
true, 1.0, 1.0);
}
}
if (getParentComponent() != nullptr)
getParentComponent()->removeChildComponent (this);
if (dropAccepted && ddt != nullptr)
{
// (note: use a local copy of this in case the callback runs
// a modal loop and deletes this object before the method completes)
DragAndDropTarget::SourceDetails details (sourceDetails);
details.localPosition = relPos;
currentlyOverComp = nullptr;
ddt->itemDropped (details);
}
// careful - this object could now be deleted..
}
}
void EnvelopeHandleComponent::mouseDown(const MouseEvent& e)
{
#ifdef MYDEBUG
printf("MyEnvelopeHandleComponent::mouseDown (%d, %d)\n", e.x, e.y);
#endif
setMouseCursor(MouseCursor::NoCursor);
if(e.mods.isShiftDown()) {
if(!shouldLockTime && !shouldLockValue)
{
getParentComponent()->setLegendTextToDefault();
removeThisHandle();
}
return; // dont send drag msg
}
else if(e.mods.isCtrlDown())
{
if(getParentComponent()->getAllowNodeEditing())
{
ignoreDrag = true;
if(PopupComponent::getActivePopups() < 1)
{
EnvelopeNodePopup::create(this, getScreenX()+e.x, getScreenY()+e.y);
}
}
}
else
{
offsetX = e.x;
offsetY = e.y;
resizeLimits.setMinimumOnscreenAmounts(HANDLESIZE,HANDLESIZE,HANDLESIZE,HANDLESIZE);
EnvelopeHandleComponent* previousHandle = getPreviousHandle();
EnvelopeHandleComponent* nextHandle = getNextHandle();
int leftLimit = previousHandle == 0 ? 0 : previousHandle->getX()+2;
int rightLimit = nextHandle == 0 ? getParentWidth()-HANDLESIZE : nextHandle->getX()-2;
// int leftLimit = previousHandle == 0 ? 0 : previousHandle->getX();
// int rightLimit = nextHandle == 0 ? getParentWidth()-HANDLESIZE : nextHandle->getX();
resizeLimits.setAdjacentHandleLimits(leftLimit, rightLimit);
dragger.startDraggingComponent(this, e);//&resizeLimits);
}
getParentComponent()->sendStartDrag();
}
void PaintElement::checkBounds (Rectangle<int>& b,
const Rectangle<int>& previousBounds,
const Rectangle<int>& limits,
const bool isStretchingTop,
const bool isStretchingLeft,
const bool isStretchingBottom,
const bool isStretchingRight)
{
if (ModifierKeys::getCurrentModifiers().isShiftDown())
setFixedAspectRatio (originalAspectRatio);
else
setFixedAspectRatio (0.0);
ComponentBoundsConstrainer::checkBounds (b, previousBounds, limits, isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);
JucerDocument* document = getDocument();
if (document != nullptr && document->isSnapActive (true))
{
jassert (getParentComponent() != nullptr);
const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());
int x = b.getX();
int y = b.getY();
int w = b.getWidth();
int h = b.getHeight();
x += borderThickness - area.getX();
y += borderThickness - area.getY();
w -= borderThickness * 2;
h -= borderThickness * 2;
int right = x + w;
int bottom = y + h;
if (isStretchingRight)
right = document->snapPosition (right);
if (isStretchingBottom)
bottom = document->snapPosition (bottom);
if (isStretchingLeft)
x = document->snapPosition (x);
if (isStretchingTop)
y = document->snapPosition (y);
w = (right - x) + borderThickness * 2;
h = (bottom - y) + borderThickness * 2;
x -= borderThickness - area.getX();
y -= borderThickness - area.getY();
b = Rectangle<int> (x, y, w, h);
}
}
void PathPointComponent::updatePosition()
{
const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());
jassert (getParentComponent() != nullptr);
double x, y;
path->getPoint (index, pointNumber, x, y, area);
setCentrePosition (roundToInt (x),
roundToInt (y));
}
//=================================================================================================
void ClipsContainer::mouseUp (const MouseEvent& event)
{
// 右键单击弹出菜单，
if (event.mouseWasClicked() && event.mods.isPopupMenu())
{
popupMenu();
controller->expandContainerWidthIfNeeded();
}
if (getParentComponent() != nullptr)
getParentComponent()->mouseUp(event);
}
void PaintElement::applyBoundsToComponent (Component*, const Rectangle<int>& newBounds)
{
if (getBounds() != newBounds)
{
getDocument()->getUndoManager().undoCurrentTransactionOnly();
jassert (dynamic_cast<PaintRoutineEditor*> (getParentComponent()) != nullptr);
setCurrentBounds (newBounds.expanded (-borderThickness, -borderThickness),
((PaintRoutineEditor*) getParentComponent())->getComponentArea(),
true);
}
}
void BubbleComponent::setPosition (Component* componentToPointTo)
{
jassert (componentToPointTo != nullptr);
Point<int> pos;
if (getParentComponent() != nullptr)
pos = getParentComponent()->getLocalPoint (componentToPointTo, pos);
else
pos = componentToPointTo->localPointToGlobal (pos);
setPosition (Rectangle<int> (pos.getX(), pos.getY(), componentToPointTo->getWidth(), componentToPointTo->getHeight()));
}
void TooltipWindow::showFor (const String& tip)
{
jassert (tip.isNotEmpty());
if (tipShowing != tip)
repaint();
tipShowing = tip;
Point<int> mousePos (Desktop::getMousePosition());
Rectangle<int> parentArea;
if (getParentComponent() != nullptr)
{
mousePos = getParentComponent()->getLocalPoint (nullptr, mousePos);
parentArea = getParentComponent()->getLocalBounds();
}
else
{
parentArea = Desktop::getInstance().getMonitorAreaContaining (mousePos);
}
int w, h;
getLookAndFeel().getTooltipSize (tip, w, h);
int x = mousePos.x;
if (x > parentArea.getCentreX())
x -= (w + 12);
else
x += 24;
int y = mousePos.y;
if (y > parentArea.getCentreY())
y -= (h + 6);
else
y += 6;
x = jlimit (parentArea.getX(), parentArea.getRight() - w, x);
y = jlimit (parentArea.getY(), parentArea.getBottom() - h, y);
setBounds (x, y, w, h);
setVisible (true);
if (getParentComponent() == nullptr)
{
addToDesktop (ComponentPeer::windowHasDropShadow
| ComponentPeer::windowIsTemporary
| ComponentPeer::windowIgnoresKeyPresses);
}
toFront (false);
}
void EnvelopeHandleComponent::updateLegend()
{
EnvelopeComponent *env = getParentComponent();
EnvelopeLegendComponent* legend = env->getLegend();
if(legend == 0) return;
String text;
int width = getParentWidth();
int places;
if(width >= 165) {
if(env && env->isLoopNode(this))
text << "(Loop) ";
else if(env && env->isReleaseNode(this))
text << "(Release) ";
else
text << "Point ";
places = 3;
}
else if(width >= 140) {
text << "Point ";
places = 3;
} else if(width >= 115) {
text << "Pt ";
places = 3;
} else if(width >= 100) {
text << "Pt ";
places = 2;
} else if(width >= 85) {
text << "Pt ";
places = 1;
} else if(width >= 65) {
text << "P ";
places = 1;
} else {
places = 1;
}
text << (getHandleIndex())
<< ": "
<< String(legend->mapTime(time), places) << legend->getTimeUnits()
<< ", "
<< String(legend->mapValue(value), places) << legend->getValueUnits();
getParentComponent()->setLegendText(text);
}
void EnvelopeHandleComponent::setValue(double valueToSet)
{
bool oldDontUpdateTimeAndValue = dontUpdateTimeAndValue;
dontUpdateTimeAndValue = true;
value = constrainValue(valueToSet);
setTopLeftPosition(getX(),
getParentComponent()->convertValueToPixels(value));
dontUpdateTimeAndValue = oldDontUpdateTimeAndValue;
getParentComponent()->repaint();
((EnvelopeComponent*)getParentComponent())->sendChangeMessage();
}
void EnvelopeHandleComponent::setTime(double timeToSet)
{
bool oldDontUpdateTimeAndValue = dontUpdateTimeAndValue;
dontUpdateTimeAndValue = true;
time = constrainDomain(timeToSet);
setTopLeftPosition(getParentComponent()->convertDomainToPixels(time),
getY());
dontUpdateTimeAndValue = oldDontUpdateTimeAndValue;
getParentComponent()->repaint();
((EnvelopeComponent*)getParentComponent())->sendChangeMessage();
}
void EditorButton::setState(bool state)
{
isEnabled = state;
if (!state)
{
removeListener((Button::Listener*) getParentComponent());
}
else
{
addListener((Button::Listener*) getParentComponent());
}
repaint();
}
void Button::turnOffOtherButtonsInGroup (const NotificationType notification)
{
if (Component* const p = getParentComponent())
{
if (radioGroupId != 0)
{
WeakReference<Component> deletionWatcher (this);
for (int i = p->getNumChildComponents(); --i >= 0;)
{
Component* const c = p->getChildComponent (i);
if (c != this)
{
if (Button* const b = dynamic_cast <Button*> (c))
{
if (b->getRadioGroupId() == radioGroupId)
{
b->setToggleState (false, notification);
if (deletionWatcher == nullptr)
return;
}
}
}
}
}
}
}
void CabbageEnvelopeHandleComponent::mouseDrag (const MouseEvent& e)
{
CabbageEnvelopeHandleComponent* previousHandle = getPreviousHandle();
CabbageEnvelopeHandleComponent* nextHandle = getNextHandle();
bool fixed = this->getProperties().getWithDefault("fixedPos", false);
int leftLimit = previousHandle == 0 ? 0 : previousHandle->getX()+1;
int rightLimit = nextHandle == 0 ? getParentWidth()-previousHandle->getHeight() : nextHandle->getX()-1;
int topLimit = previousHandle == 0 ? 0 : previousHandle->getX()+1;
int bottomLimit = nextHandle == 0 ? getParentWidth()-previousHandle->getHeight() : nextHandle->getX()-1;
int dragX = x+e.getDistanceFromDragStartX();
int dragY = y+e.getDistanceFromDragStartY();
//dragger.dragComponent(this, e, &resizeLimits);
if(dragX < leftLimit)
dragX = leftLimit;
if(dragX > rightLimit)
dragX = rightLimit;
if(dragY< 0)
dragY = 0;
if(dragY > height-5)
dragY = height-5;
if(fixed)
dragX = x;
this->setTopLeftPosition(dragX, dragY);
getParentComponent()->repaint();
}
double EnvelopeHandleComponent::constrainDomain(double domainToConstrain) const
{
EnvelopeHandleComponent* previousHandle = getPreviousHandle();
EnvelopeHandleComponent* nextHandle = getNextHandle();
int leftLimit = previousHandle == 0 ? 0 : previousHandle->getX();
int rightLimit = nextHandle == 0 ? getParentWidth()-HANDLESIZE : nextHandle->getX();
double left = getParentComponent()->convertPixelsToDomain(leftLimit);
double right = getParentComponent()->convertPixelsToDomain(rightLimit);
if(previousHandle != 0) left += FINETUNE;
if(nextHandle != 0) right -= FINETUNE;
return jlimit(left, right, shouldLockTime ? time : domainToConstrain);
}
void EnvelopeHandleComponent::paint(Graphics& g)
{
EnvelopeComponent *env = getParentComponent();
RGBAColour handleColour;
if(env == 0)
{
handleColour = 0xFF69B4FF;
}
else if(env->isReleaseNode(this))
{
handleColour = env->getEnvColour(EnvelopeComponent::ReleaseNode);
}
else if(env->isLoopNode(this))
{
handleColour = env->getEnvColour(EnvelopeComponent::LoopNode);
}
else
{
handleColour = env->getEnvColour(EnvelopeComponent::Node);
}
g.setColour(handleColour);
g.fillRect(1, 1, getWidth()-2, getHeight()-2);
}
DragAndDropTarget* findTarget (const Point<int>& screenPos, Point<int>& relativePos)
{
Component* hit = getParentComponent();
if (hit == nullptr)
{
hit = Desktop::getInstance().findComponentAt (screenPos);
}
else
{
const Point<int> relPos (hit->getLocalPoint (nullptr, screenPos));
hit = hit->getComponentAt (relPos.getX(), relPos.getY());
}
// (note: use a local copy of this in case the callback runs
// a modal loop and deletes this object before the method completes)
const DragAndDropTarget::SourceDetails details (sourceDetails);
while (hit != nullptr)
{
DragAndDropTarget* const ddt = dynamic_cast <DragAndDropTarget*> (hit);
if (ddt != nullptr && ddt->isInterestedInDragSource (details))
{
relativePos = hit->getLocalPoint (nullptr, screenPos);
return ddt;
}
hit = hit->getParentComponent();
}
return nullptr;
}
void PaintElement::paint (Graphics& g)
{
Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());
g.saveState();
g.setOrigin (area.getPosition() - Component::getPosition());
area.setPosition (0, 0);
g.saveState();
g.reduceClipRegion (0, 0, area.getWidth(), area.getHeight());
draw (g, getDocument()->getComponentLayout(), area);
g.restoreState();
drawExtraEditorGraphics (g, area);
g.restoreState();
if (selected)
{
const BorderSize<int> borderSize (border->getBorderThickness());
drawResizableBorder (g, getWidth(), getHeight(), borderSize,
(isMouseOverOrDragging() || border->isMouseOverOrDragging()));
}
else if (isMouseOverOrDragging())
{
drawMouseOverCorners (g, getWidth(), getHeight());
}
}
void mouseDrag (const MouseEvent& e)
{
if (! e.mods.isPopupMenu())
{
Point<int> pos (originalPos + Point<int> (e.getDistanceFromDragStartX(), e.getDistanceFromDragStartY()));
if (getParentComponent() != nullptr)
pos = getParentComponent()->getLocalPoint (nullptr, pos);
graph.setNodePosition (filterID,
(pos.getX() + getWidth() / 2) / (double) getParentWidth(),
(pos.getY() + getHeight() / 2) / (double) getParentHeight());
getGraphPanel()->updateComponents();
}
}
