The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

677 lines
22KB

  1. /*
  2. ==============================================================================
  3. This file is part of the JUCE library.
  4. Copyright (c) 2013 - Raw Material Software Ltd.
  5. Permission is granted to use this software under the terms of either:
  6. a) the GPL v2 (or any later version)
  7. b) the Affero GPL v3
  8. Details of these licenses can be found at: www.gnu.org/licenses
  9. JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  10. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  11. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  12. ------------------------------------------------------------------------------
  13. To release a closed-source product which uses JUCE, commercial licenses are
  14. available: visit www.juce.com for more information.
  15. ==============================================================================
  16. */
  17. namespace
  18. {
  19. template <typename Type>
  20. Rectangle<Type> coordsToRectangle (Type x, Type y, Type w, Type h)
  21. {
  22. #if JUCE_DEBUG
  23. const int maxVal = 0x3fffffff;
  24. jassert ((int) x >= -maxVal && (int) x <= maxVal
  25. && (int) y >= -maxVal && (int) y <= maxVal
  26. && (int) w >= -maxVal && (int) w <= maxVal
  27. && (int) h >= -maxVal && (int) h <= maxVal);
  28. #endif
  29. return Rectangle<Type> (x, y, w, h);
  30. }
  31. }
  32. //==============================================================================
  33. LowLevelGraphicsContext::LowLevelGraphicsContext() {}
  34. LowLevelGraphicsContext::~LowLevelGraphicsContext() {}
  35. //==============================================================================
  36. Graphics::Graphics (const Image& imageToDrawOnto)
  37. : context (*imageToDrawOnto.createLowLevelContext()),
  38. contextToDelete (&context),
  39. saveStatePending (false)
  40. {
  41. jassert (imageToDrawOnto.isValid()); // Can't draw into a null image!
  42. }
  43. Graphics::Graphics (LowLevelGraphicsContext& internalContext) noexcept
  44. : context (internalContext),
  45. saveStatePending (false)
  46. {
  47. }
  48. Graphics::~Graphics()
  49. {
  50. }
  51. //==============================================================================
  52. void Graphics::resetToDefaultState()
  53. {
  54. saveStateIfPending();
  55. context.setFill (FillType());
  56. context.setFont (Font());
  57. context.setInterpolationQuality (Graphics::mediumResamplingQuality);
  58. }
  59. bool Graphics::isVectorDevice() const
  60. {
  61. return context.isVectorDevice();
  62. }
  63. bool Graphics::reduceClipRegion (const Rectangle<int>& area)
  64. {
  65. saveStateIfPending();
  66. return context.clipToRectangle (area);
  67. }
  68. bool Graphics::reduceClipRegion (const int x, const int y, const int w, const int h)
  69. {
  70. return reduceClipRegion (Rectangle<int> (x, y, w, h));
  71. }
  72. bool Graphics::reduceClipRegion (const RectangleList<int>& clipRegion)
  73. {
  74. saveStateIfPending();
  75. return context.clipToRectangleList (clipRegion);
  76. }
  77. bool Graphics::reduceClipRegion (const Path& path, const AffineTransform& transform)
  78. {
  79. saveStateIfPending();
  80. context.clipToPath (path, transform);
  81. return ! context.isClipEmpty();
  82. }
  83. bool Graphics::reduceClipRegion (const Image& image, const AffineTransform& transform)
  84. {
  85. saveStateIfPending();
  86. context.clipToImageAlpha (image, transform);
  87. return ! context.isClipEmpty();
  88. }
  89. void Graphics::excludeClipRegion (const Rectangle<int>& rectangleToExclude)
  90. {
  91. saveStateIfPending();
  92. context.excludeClipRectangle (rectangleToExclude);
  93. }
  94. bool Graphics::isClipEmpty() const
  95. {
  96. return context.isClipEmpty();
  97. }
  98. Rectangle<int> Graphics::getClipBounds() const
  99. {
  100. return context.getClipBounds();
  101. }
  102. void Graphics::saveState()
  103. {
  104. saveStateIfPending();
  105. saveStatePending = true;
  106. }
  107. void Graphics::restoreState()
  108. {
  109. if (saveStatePending)
  110. saveStatePending = false;
  111. else
  112. context.restoreState();
  113. }
  114. void Graphics::saveStateIfPending()
  115. {
  116. if (saveStatePending)
  117. {
  118. saveStatePending = false;
  119. context.saveState();
  120. }
  121. }
  122. void Graphics::setOrigin (Point<int> newOrigin)
  123. {
  124. saveStateIfPending();
  125. context.setOrigin (newOrigin);
  126. }
  127. void Graphics::setOrigin (int x, int y)
  128. {
  129. setOrigin (Point<int> (x, y));
  130. }
  131. void Graphics::addTransform (const AffineTransform& transform)
  132. {
  133. saveStateIfPending();
  134. context.addTransform (transform);
  135. }
  136. bool Graphics::clipRegionIntersects (const Rectangle<int>& area) const
  137. {
  138. return context.clipRegionIntersects (area);
  139. }
  140. void Graphics::beginTransparencyLayer (float layerOpacity)
  141. {
  142. saveStateIfPending();
  143. context.beginTransparencyLayer (layerOpacity);
  144. }
  145. void Graphics::endTransparencyLayer()
  146. {
  147. context.endTransparencyLayer();
  148. }
  149. //==============================================================================
  150. void Graphics::setColour (Colour newColour)
  151. {
  152. saveStateIfPending();
  153. context.setFill (newColour);
  154. }
  155. void Graphics::setOpacity (const float newOpacity)
  156. {
  157. saveStateIfPending();
  158. context.setOpacity (newOpacity);
  159. }
  160. void Graphics::setGradientFill (const ColourGradient& gradient)
  161. {
  162. setFillType (gradient);
  163. }
  164. void Graphics::setTiledImageFill (const Image& imageToUse, const int anchorX, const int anchorY, const float opacity)
  165. {
  166. saveStateIfPending();
  167. context.setFill (FillType (imageToUse, AffineTransform::translation ((float) anchorX, (float) anchorY)));
  168. context.setOpacity (opacity);
  169. }
  170. void Graphics::setFillType (const FillType& newFill)
  171. {
  172. saveStateIfPending();
  173. context.setFill (newFill);
  174. }
  175. //==============================================================================
  176. void Graphics::setFont (const Font& newFont)
  177. {
  178. saveStateIfPending();
  179. context.setFont (newFont);
  180. }
  181. void Graphics::setFont (const float newFontHeight)
  182. {
  183. setFont (context.getFont().withHeight (newFontHeight));
  184. }
  185. Font Graphics::getCurrentFont() const
  186. {
  187. return context.getFont();
  188. }
  189. //==============================================================================
  190. void Graphics::drawSingleLineText (const String& text, const int startX, const int baselineY,
  191. Justification justification) const
  192. {
  193. if (text.isNotEmpty())
  194. {
  195. // Don't pass any vertical placement flags to this method - they'll be ignored.
  196. jassert (justification.getOnlyVerticalFlags() == 0);
  197. const int flags = justification.getOnlyHorizontalFlags();
  198. if (flags == Justification::right)
  199. {
  200. if (startX < context.getClipBounds().getX())
  201. return;
  202. }
  203. else if (flags == Justification::left)
  204. if (startX > context.getClipBounds().getRight())
  205. return;
  206. GlyphArrangement arr;
  207. arr.addLineOfText (context.getFont(), text, (float) startX, (float) baselineY);
  208. if (flags != Justification::left)
  209. {
  210. float w = arr.getBoundingBox (0, -1, true).getWidth();
  211. if ((flags & (Justification::horizontallyCentred | Justification::horizontallyJustified)) != 0)
  212. w /= 2.0f;
  213. arr.draw (*this, AffineTransform::translation (-w, 0));
  214. }
  215. else
  216. {
  217. arr.draw (*this);
  218. }
  219. }
  220. }
  221. void Graphics::drawMultiLineText (const String& text, const int startX,
  222. const int baselineY, const int maximumLineWidth) const
  223. {
  224. if (text.isNotEmpty()
  225. && startX < context.getClipBounds().getRight())
  226. {
  227. GlyphArrangement arr;
  228. arr.addJustifiedText (context.getFont(), text,
  229. (float) startX, (float) baselineY, (float) maximumLineWidth,
  230. Justification::left);
  231. arr.draw (*this);
  232. }
  233. }
  234. void Graphics::drawText (const String& text, const Rectangle<int>& area,
  235. Justification justificationType,
  236. const bool useEllipsesIfTooBig) const
  237. {
  238. if (text.isNotEmpty() && context.clipRegionIntersects (area))
  239. {
  240. GlyphArrangement arr;
  241. arr.addCurtailedLineOfText (context.getFont(), text,
  242. 0.0f, 0.0f, (float) area.getWidth(),
  243. useEllipsesIfTooBig);
  244. arr.justifyGlyphs (0, arr.getNumGlyphs(),
  245. (float) area.getX(), (float) area.getY(),
  246. (float) area.getWidth(), (float) area.getHeight(),
  247. justificationType);
  248. arr.draw (*this);
  249. }
  250. }
  251. void Graphics::drawText (const String& text, const int x, const int y, const int width, const int height,
  252. Justification justificationType,
  253. const bool useEllipsesIfTooBig) const
  254. {
  255. drawText (text, Rectangle<int> (x, y, width, height), justificationType, useEllipsesIfTooBig);
  256. }
  257. void Graphics::drawFittedText (const String& text, const Rectangle<int>& area,
  258. Justification justification,
  259. const int maximumNumberOfLines,
  260. const float minimumHorizontalScale) const
  261. {
  262. if (text.isNotEmpty() && (! area.isEmpty()) && context.clipRegionIntersects (area))
  263. {
  264. GlyphArrangement arr;
  265. arr.addFittedText (context.getFont(), text,
  266. (float) area.getX(), (float) area.getY(),
  267. (float) area.getWidth(), (float) area.getHeight(),
  268. justification,
  269. maximumNumberOfLines,
  270. minimumHorizontalScale);
  271. arr.draw (*this);
  272. }
  273. }
  274. void Graphics::drawFittedText (const String& text, const int x, const int y, const int width, const int height,
  275. Justification justification,
  276. const int maximumNumberOfLines,
  277. const float minimumHorizontalScale) const
  278. {
  279. drawFittedText (text, coordsToRectangle (x, y, width, height),
  280. justification, maximumNumberOfLines, minimumHorizontalScale);
  281. }
  282. //==============================================================================
  283. void Graphics::fillRect (const Rectangle<int>& r) const
  284. {
  285. context.fillRect (r, false);
  286. }
  287. void Graphics::fillRect (const Rectangle<float>& r) const
  288. {
  289. context.fillRect (r);
  290. }
  291. void Graphics::fillRect (int x, int y, int width, int height) const
  292. {
  293. context.fillRect (coordsToRectangle (x, y, width, height), false);
  294. }
  295. void Graphics::fillRect (float x, float y, float width, float height) const
  296. {
  297. fillRect (coordsToRectangle (x, y, width, height));
  298. }
  299. void Graphics::fillRectList (const RectangleList<float>& rectangles) const
  300. {
  301. context.fillRectList (rectangles);
  302. }
  303. void Graphics::fillRectList (const RectangleList<int>& rects) const
  304. {
  305. for (const Rectangle<int>* r = rects.begin(), * const e = rects.end(); r != e; ++r)
  306. context.fillRect (*r, false);
  307. }
  308. void Graphics::setPixel (int x, int y) const
  309. {
  310. context.fillRect (Rectangle<int> (x, y, 1, 1), false);
  311. }
  312. void Graphics::fillAll() const
  313. {
  314. fillRect (context.getClipBounds());
  315. }
  316. void Graphics::fillAll (Colour colourToUse) const
  317. {
  318. if (! colourToUse.isTransparent())
  319. {
  320. const Rectangle<int> clip (context.getClipBounds());
  321. context.saveState();
  322. context.setFill (colourToUse);
  323. context.fillRect (clip, false);
  324. context.restoreState();
  325. }
  326. }
  327. //==============================================================================
  328. void Graphics::fillPath (const Path& path, const AffineTransform& transform) const
  329. {
  330. if ((! context.isClipEmpty()) && ! path.isEmpty())
  331. context.fillPath (path, transform);
  332. }
  333. void Graphics::strokePath (const Path& path,
  334. const PathStrokeType& strokeType,
  335. const AffineTransform& transform) const
  336. {
  337. Path stroke;
  338. strokeType.createStrokedPath (stroke, path, transform, context.getPhysicalPixelScaleFactor());
  339. fillPath (stroke);
  340. }
  341. //==============================================================================
  342. void Graphics::drawRect (float x, float y, float width, float height, float lineThickness) const
  343. {
  344. drawRect (coordsToRectangle (x, y, width, height), lineThickness);
  345. }
  346. void Graphics::drawRect (int x, int y, int width, int height, int lineThickness) const
  347. {
  348. drawRect (coordsToRectangle (x, y, width, height), lineThickness);
  349. }
  350. void Graphics::drawRect (const Rectangle<int>& r, int lineThickness) const
  351. {
  352. drawRect (r.toFloat(), (float) lineThickness);
  353. }
  354. void Graphics::drawRect (Rectangle<float> r, const float lineThickness) const
  355. {
  356. RectangleList<float> rects;
  357. rects.addWithoutMerging (r.removeFromTop (lineThickness));
  358. rects.addWithoutMerging (r.removeFromBottom (lineThickness));
  359. rects.addWithoutMerging (r.removeFromLeft (lineThickness));
  360. rects.addWithoutMerging (r.removeFromRight (lineThickness));
  361. context.fillRectList (rects);
  362. }
  363. //==============================================================================
  364. void Graphics::fillEllipse (const Rectangle<float>& area) const
  365. {
  366. fillEllipse (area.getX(), area.getY(), area.getWidth(), area.getHeight());
  367. }
  368. void Graphics::fillEllipse (float x, float y, float width, float height) const
  369. {
  370. Path p;
  371. p.addEllipse (x, y, width, height);
  372. fillPath (p);
  373. }
  374. void Graphics::drawEllipse (float x, float y, float width, float height, float lineThickness) const
  375. {
  376. Path p;
  377. p.addEllipse (x, y, width, height);
  378. strokePath (p, PathStrokeType (lineThickness));
  379. }
  380. void Graphics::drawEllipse (const Rectangle<float>& area, float lineThickness) const
  381. {
  382. drawEllipse (area.getX(), area.getY(), area.getWidth(), area.getHeight(), lineThickness);
  383. }
  384. void Graphics::fillRoundedRectangle (float x, float y, float width, float height, float cornerSize) const
  385. {
  386. fillRoundedRectangle (coordsToRectangle (x, y, width, height), cornerSize);
  387. }
  388. void Graphics::fillRoundedRectangle (const Rectangle<float>& r, const float cornerSize) const
  389. {
  390. Path p;
  391. p.addRoundedRectangle (r, cornerSize);
  392. fillPath (p);
  393. }
  394. void Graphics::drawRoundedRectangle (float x, float y, float width, float height,
  395. float cornerSize, float lineThickness) const
  396. {
  397. drawRoundedRectangle (coordsToRectangle (x, y, width, height), cornerSize, lineThickness);
  398. }
  399. void Graphics::drawRoundedRectangle (const Rectangle<float>& r, float cornerSize, float lineThickness) const
  400. {
  401. Path p;
  402. p.addRoundedRectangle (r, cornerSize);
  403. strokePath (p, PathStrokeType (lineThickness));
  404. }
  405. void Graphics::drawArrow (const Line<float>& line, float lineThickness, float arrowheadWidth, float arrowheadLength) const
  406. {
  407. Path p;
  408. p.addArrow (line, lineThickness, arrowheadWidth, arrowheadLength);
  409. fillPath (p);
  410. }
  411. void Graphics::fillCheckerBoard (const Rectangle<int>& area,
  412. const int checkWidth, const int checkHeight,
  413. Colour colour1, Colour colour2) const
  414. {
  415. jassert (checkWidth > 0 && checkHeight > 0); // can't be zero or less!
  416. if (checkWidth > 0 && checkHeight > 0)
  417. {
  418. context.saveState();
  419. if (colour1 == colour2)
  420. {
  421. context.setFill (colour1);
  422. context.fillRect (area, false);
  423. }
  424. else
  425. {
  426. const Rectangle<int> clipped (context.getClipBounds().getIntersection (area));
  427. if (! clipped.isEmpty())
  428. {
  429. context.clipToRectangle (clipped);
  430. const int checkNumX = (clipped.getX() - area.getX()) / checkWidth;
  431. const int checkNumY = (clipped.getY() - area.getY()) / checkHeight;
  432. const int startX = area.getX() + checkNumX * checkWidth;
  433. const int startY = area.getY() + checkNumY * checkHeight;
  434. const int right = clipped.getRight();
  435. const int bottom = clipped.getBottom();
  436. for (int i = 0; i < 2; ++i)
  437. {
  438. context.setFill (i == ((checkNumX ^ checkNumY) & 1) ? colour1 : colour2);
  439. int cy = i;
  440. for (int y = startY; y < bottom; y += checkHeight)
  441. for (int x = startX + (cy++ & 1) * checkWidth; x < right; x += checkWidth * 2)
  442. context.fillRect (Rectangle<int> (x, y, checkWidth, checkHeight), false);
  443. }
  444. }
  445. }
  446. context.restoreState();
  447. }
  448. }
  449. //==============================================================================
  450. void Graphics::drawVerticalLine (const int x, float top, float bottom) const
  451. {
  452. if (top < bottom)
  453. context.fillRect (Rectangle<float> ((float) x, top, 1.0f, bottom - top));
  454. }
  455. void Graphics::drawHorizontalLine (const int y, float left, float right) const
  456. {
  457. if (left < right)
  458. context.fillRect (Rectangle<float> (left, (float) y, right - left, 1.0f));
  459. }
  460. void Graphics::drawLine (const Line<float>& line) const
  461. {
  462. context.drawLine (line);
  463. }
  464. void Graphics::drawLine (float x1, float y1, float x2, float y2) const
  465. {
  466. context.drawLine (Line<float> (x1, y1, x2, y2));
  467. }
  468. void Graphics::drawLine (float x1, float y1, float x2, float y2, float lineThickness) const
  469. {
  470. drawLine (Line<float> (x1, y1, x2, y2), lineThickness);
  471. }
  472. void Graphics::drawLine (const Line<float>& line, const float lineThickness) const
  473. {
  474. Path p;
  475. p.addLineSegment (line, lineThickness);
  476. fillPath (p);
  477. }
  478. void Graphics::drawDashedLine (const Line<float>& line, const float* const dashLengths,
  479. const int numDashLengths, const float lineThickness, int n) const
  480. {
  481. jassert (n >= 0 && n < numDashLengths); // your start index must be valid!
  482. const Point<double> delta ((line.getEnd() - line.getStart()).toDouble());
  483. const double totalLen = delta.getDistanceFromOrigin();
  484. if (totalLen >= 0.1)
  485. {
  486. const double onePixAlpha = 1.0 / totalLen;
  487. for (double alpha = 0.0; alpha < 1.0;)
  488. {
  489. jassert (dashLengths[n] > 0); // can't have zero-length dashes!
  490. const double lastAlpha = alpha;
  491. alpha += dashLengths [n] * onePixAlpha;
  492. n = (n + 1) % numDashLengths;
  493. if ((n & 1) != 0)
  494. {
  495. const Line<float> segment (line.getStart() + (delta * lastAlpha).toFloat(),
  496. line.getStart() + (delta * jmin (1.0, alpha)).toFloat());
  497. if (lineThickness != 1.0f)
  498. drawLine (segment, lineThickness);
  499. else
  500. context.drawLine (segment);
  501. }
  502. }
  503. }
  504. }
  505. //==============================================================================
  506. void Graphics::setImageResamplingQuality (const Graphics::ResamplingQuality newQuality)
  507. {
  508. saveStateIfPending();
  509. context.setInterpolationQuality (newQuality);
  510. }
  511. //==============================================================================
  512. void Graphics::drawImageAt (const Image& imageToDraw, int x, int y, bool fillAlphaChannel) const
  513. {
  514. drawImageTransformed (imageToDraw,
  515. AffineTransform::translation ((float) x, (float) y),
  516. fillAlphaChannel);
  517. }
  518. void Graphics::drawImageWithin (const Image& imageToDraw,
  519. int dx, int dy, int dw, int dh,
  520. RectanglePlacement placementWithinTarget,
  521. const bool fillAlphaChannelWithCurrentBrush) const
  522. {
  523. if (imageToDraw.isValid())
  524. drawImageTransformed (imageToDraw,
  525. placementWithinTarget.getTransformToFit (imageToDraw.getBounds().toFloat(),
  526. coordsToRectangle (dx, dy, dw, dh).toFloat()),
  527. fillAlphaChannelWithCurrentBrush);
  528. }
  529. void Graphics::drawImage (const Image& imageToDraw,
  530. int dx, int dy, int dw, int dh,
  531. int sx, int sy, int sw, int sh,
  532. const bool fillAlphaChannelWithCurrentBrush) const
  533. {
  534. if (imageToDraw.isValid() && context.clipRegionIntersects (coordsToRectangle (dx, dy, dw, dh)))
  535. drawImageTransformed (imageToDraw.getClippedImage (coordsToRectangle (sx, sy, sw, sh)),
  536. AffineTransform::scale (dw / (float) sw, dh / (float) sh)
  537. .translated ((float) dx, (float) dy),
  538. fillAlphaChannelWithCurrentBrush);
  539. }
  540. void Graphics::drawImageTransformed (const Image& imageToDraw,
  541. const AffineTransform& transform,
  542. const bool fillAlphaChannelWithCurrentBrush) const
  543. {
  544. if (imageToDraw.isValid() && ! context.isClipEmpty())
  545. {
  546. if (fillAlphaChannelWithCurrentBrush)
  547. {
  548. context.saveState();
  549. context.clipToImageAlpha (imageToDraw, transform);
  550. fillAll();
  551. context.restoreState();
  552. }
  553. else
  554. {
  555. context.drawImage (imageToDraw, transform);
  556. }
  557. }
  558. }
  559. //==============================================================================
  560. Graphics::ScopedSaveState::ScopedSaveState (Graphics& g) : context (g)
  561. {
  562. context.saveState();
  563. }
  564. Graphics::ScopedSaveState::~ScopedSaveState()
  565. {
  566. context.restoreState();
  567. }