paintdev.h

[詳解]

/*
 * Copyright 2002-2021 oZ/acy (名賀月晃嗣)
 * Redistribution and use in source and binary forms, 
 *     with or without modification, 
 *   are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#ifndef INCLUDE_GUARD_URANIA_PAINTDEVICE_H
#define INCLUDE_GUARD_URANIA_PAINTDEVICE_H
 
// windows.hのmin/maxマクロの抑止
#ifndef NOMINMAX
#define NOMINMAX
#endif 
 
#include <windows.h>
#include <eunomia/picture.h>
#include <eunomia/picture_indexed.h>
 
namespace urania
{
  class Color
  {
  public:
    std::uint8_t blue;
    std::uint8_t green;
    std::uint8_t red;
 
  public:
    constexpr Color() noexcept : blue(0), green(0), red(0) {}
    constexpr Color(std::uint8_t r, std::uint8_t g, std::uint8_t b) noexcept
      : blue(b), green(g), red(r)
      {}
    constexpr Color(const eunomia::RgbColour& org) noexcept
      : blue(org.blue), green(org.green), red(org.red)
      {}
    constexpr explicit Color(COLORREF cr) noexcept
      : blue(GetBValue(cr)), green(GetGValue(cr)), red(GetRValue(cr))
      {}
 
    Color& operator=(const eunomia::RgbColour& org) noexcept
    {
      red = org.red;
      green = org.green;
      blue = org.blue;
      return *this;
    }
 
    constexpr COLORREF getColorref() const noexcept
    {
      return
        (std::uint8_t)red
        | ((std::uint8_t)green << 8)
        | ((std::uint8_t)blue << 16);
    }
 
    constexpr operator eunomia::RgbColour() const noexcept
    {
      return eunomia::RgbColour(red, green, blue);
    }
  };
 
 
  // class宣言
  class PaintDevice;
  class PaintMemDevice;
  class PaintMemDeviceIndexed;
 
 
}// end of namespace urania
 
 
 
 
class urania::PaintMemDevice : public eunomia::ImageBuffer<urania::Color>
{
  friend class urania::PaintDevice;
 
protected:
  HDC hdc_;
  HBITMAP oldbmp_;
 
 
protected:
  PaintMemDevice(unsigned ww, unsigned hh);
 
public:
  ~PaintMemDevice();
 
  static std::unique_ptr<PaintMemDevice> create(unsigned w, unsigned h);
 
  static
  std::unique_ptr<PaintMemDevice> duplicate(const eunomia::Picture& pct);
 
  std::unique_ptr<eunomia::Picture> duplicatePicture() const;
 
  std::unique_ptr<PaintMemDevice> clone() const;
};
 
 
 
class urania::PaintMemDeviceIndexed : public eunomia::ImageBuffer<std::uint8_t>
{
  friend class urania::PaintDevice;
 
protected:
  HDC hdc_;
  urania::Color pal_[256];
  HPALETTE hpal_;
  HBITMAP oldbmp_;
  urania::Color oldpal_[256];
 
  PaintMemDeviceIndexed(unsigned ww, unsigned hh);
 
 public:
  ~PaintMemDeviceIndexed();
 
  static std::unique_ptr<PaintMemDeviceIndexed> create(unsigned w, unsigned h);
 
  static std::unique_ptr<PaintMemDeviceIndexed>
  duplicate(const eunomia::PictureIndexed& pct);
 
  std::unique_ptr<eunomia::PictureIndexed> duplicatePictureIndexed() const;
 
  std::unique_ptr<PaintMemDeviceIndexed> clone() const;
 
  urania::Color& palette(int id) { return pal_[id]; }
  const urania::Color& palette(int id) const { return pal_[id]; }
  urania::Color* paletteBuffer() noexcept { return pal_; }
  const urania::Color* paletteBuffer() const noexcept { return pal_; }
 
  void updatePalette();
};
 
 
 
class urania::PaintDevice : eunomia::Noncopyable<urania::PaintDevice>
{
public:
  typedef void (*DestProc)(HDC, void*);
 
protected:
  HDC hdc_;
  int width_, height_;
 
  HBRUSH obr_;
  HPEN   opn_;
  HFONT  oft_;
  int    obm_;
 
  void* app_;
  DestProc dst_;
 
 
protected:
  PaintDevice(HDC dc, DestProc dp, void* a, int w, int h);
 
public:
  ~PaintDevice();
 
 
  static
  std::unique_ptr<PaintDevice>
  create(HDC dc, DestProc dp, void* a, int w, int h);
 
 
  void clear(const urania::Color& col);
 
  void dotset(int x, int y, const urania::Color& col);
 
  void line(int x1, int y1, int x2, int y2, const urania::Color& col);
 
  void box(
    int x1, int y1, int x2, int y2, const urania::Color& col, bool f =false);
 
  void ellipse(
    int x, int y, int a, int b, const urania::Color& col, bool f =false);
 
  void circle(int x, int y, int r, const urania::Color& col, bool f =false)
  {
    ellipse(x, y, r, r, col, f);
  }
 
  eunomia::Point
  text(int x, int y, const std::wstring& str, const urania::Color& col);
 
  eunomia::Point
  text(int x, int y, int w, const std::wstring& str, const urania::Color& col);
 
  void
  changeFont(
    int size, const std::wstring& fn, bool ro, bool fx,
    bool bo, bool itl, bool ul, bool sk);
 
 
  int width() const { return width_; }
 
  int height() const { return height_; }
 
 
  void blt(
    const urania::PaintMemDevice& src, int sx, int sy, int w, int h,
    int dx, int dy,
    const std::optional<eunomia::Rect>& cliprect = std::nullopt);
 
  void blt(
    urania::PaintMemDeviceIndexed& src, int sx, int sy, int w, int h,
    int dx, int dy,
    const std::optional<eunomia::Rect>& cliprect = std::nullopt);
 
  void stretchBlt(const urania::PaintMemDevice& src);
 
  void stretchBlt(urania::PaintMemDeviceIndexed& src);
 
  void blt(const urania::PaintMemDevice& src);
 
  void blt(urania::PaintMemDeviceIndexed& src);
 
 
  static urania::Color getSysColor(int id)
  {
    return Color(::GetSysColor(id));
  }
 
  static void setSysColor(int id, const urania::Color& col);
 
 
private:
  void changeBrush_(const urania::Color& col);
  void changePen_(const urania::Color& col);
};
 
 
 
 
#endif // INCLUDE_GUARD_URANIA_PAINTDEVICE_H