wipdev

6 files changed, 415 insertions, 133 deletions

diff --git a/include/ncurses/basic_winbuf.hpp b/include/ncurses/basic_winbuf.hpp
new file mode 100644
index 0000000..adc424a
--- /dev/null
+++ b/include/ncurses/basic_winbuf.hpp
@@ -0,0 +1,48 @@
+#ifndef INCLUDE_NCURSES_BASIC_WINBUF_HPP_
+#define INCLUDE_NCURSES_BASIC_WINBUF_HPP_
+
+#include <streambuf>
+
+#include <ncurses.h>
+
+#include <ncurses/utils/preamble.hpp>
+#include <ncurses/window.hpp>
+
+namespace NCURSES_CPP_NAMESPACE {
+
+template <typename CharT, typename Traits = std::char_traits<CharT>>
+class basic_winbuf final : public std::basic_streambuf<CharT, Traits> {
+public:
+  using Base = std::basic_streambuf<CharT, Traits>;
+  using typename Base::char_type;
+  using typename Base::int_type;
+  using typename Base::off_type;
+  using typename Base::pos_type;
+
+  explicit basic_winbuf(window &win) : win_(win), x_pos_(0), y_pos_(0) {}
+
+  /*int_type uflow() override {}*/
+  /*int_type underflow() override {}*/
+  int_type overflow(int_type ch = Traits::eof()) override {}
+  std::streamsize xsputn(const char_type *s, std::streamsize n) override {
+    // TODO: change to call to new trait's callback for each supported type
+    // for char/wchar_t/other_chars use wadd(w)nstr
+    // for curs_char/curs_wchar use for loop of wadd(w)ch
+    waddnstr(static_cast<WINDOW *>(win_), s, n);
+  }
+  // TODO: overload << operator with full_attrs to do attr_on, etc...
+
+  void pos(int y_pos, int x_pos) NCURSES_CPP_NOEXCEPT {
+    y_pos_ = y_pos;
+    x_pos_ = x_pos;
+  }
+
+private:
+  window &win_;
+  int x_pos_;
+  int y_pos_;
+};
+
+} // namespace NCURSES_CPP_NAMESPACE
+
+#endif // INCLUDE_NCURSES_BASIC_WINBUF_HPP_
diff --git a/include/ncurses/colors.hpp b/include/ncurses/colors.hpp
index a0622a9..e045ebb 100644
--- a/include/ncurses/colors.hpp
+++ b/include/ncurses/colors.hpp
@@ -8,6 +8,7 @@
 
 namespace NCURSES_CPP_NAMESPACE {
 
+// TODO: there is no usage for this for now
 enum class curs_color {
   black = COLOR_BLACK,
   red = COLOR_RED,
@@ -25,17 +26,19 @@ struct rgb_color {
   unsigned char b;
 };
 
-NCURSES_CPP_CONSTEXPR static int
+NCURSES_CPP_CONSTEXPR_INLINE static int
 rgb_to_curses(unsigned char c) NCURSES_CPP_NOEXCEPT {
   return static_cast<int>(c) * 1000 / 255;
 }
 
-NCURSES_CPP_CONSTEXPR static unsigned char
+NCURSES_CPP_CONSTEXPR_INLINE static unsigned char
 curses_to_rgb(int c) NCURSES_CPP_NOEXCEPT {
   return static_cast<unsigned char>((c * 255 / 1000) +
                                     (c * 255 % 1000 == 0 ? 0 : 1));
 }
 
+// TODO: start_color maybe needs to be defined somewhere else
+
 inline bool has_colors() { return static_cast<bool>(::has_colors()); }
 
 inline bool can_change_color() {
diff --git a/include/ncurses/curs_char.hpp b/include/ncurses/curs_char.hpp
index 8c1cf4a..18d250a 100644
--- a/include/ncurses/curs_char.hpp
+++ b/include/ncurses/curs_char.hpp
@@ -35,103 +35,156 @@ public:
     return static_cast<char>(value_);
   };
 
-#define NCURSES_CPP_RELATIONAL(op)                                             \
-  NCURSES_CPP_CONSTEXPR bool operator op(curs_char const &rhs)                 \
-      const NCURSES_CPP_NOEXCEPT {                                             \
-    return value_ op rhs.value_;                                               \
+  // relational operators
+  NCURSES_CPP_CONSTEXPR bool
+  operator<(curs_char const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return value_ < rhs.value_;
   }
-
-#define NCURSES_CPP_BITWISE_ATTR(op)                                           \
-  NCURSES_CPP_CONSTEXPR curs_char operator op(attr rhs)                        \
-      const NCURSES_CPP_NOEXCEPT {                                             \
-    return curs_char(                                                          \
-        value_ op static_cast<std::underlying_type<attr>::type>(rhs));         \
+  NCURSES_CPP_CONSTEXPR bool
+  operator<=(curs_char const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return value_ <= rhs.value_;
   }
-
-#define NCURSES_CPP_ASSIGNMENT_ATTR(op)                                        \
-  NCURSES_CPP_CONSTEXPR_14 curs_char &operator op##=(attr rhs)                 \
-      NCURSES_CPP_NOEXCEPT {                                                   \
-    value_ op## = static_cast<std::underlying_type<attr>::type>(rhs);          \
-    return *this;                                                              \
+  NCURSES_CPP_CONSTEXPR bool
+  operator>(curs_char const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return value_ > rhs.value_;
   }
-
-#define NCURSES_CPP_BITWISE_ATTRS(op)                                          \
-  NCURSES_CPP_CONSTEXPR curs_char operator op(attr_flags const &rhs)           \
-      const NCURSES_CPP_NOEXCEPT {                                             \
-    return curs_char(value_ op static_cast<attr_flags::mask_type>(rhs));       \
+  NCURSES_CPP_CONSTEXPR bool
+  operator>=(curs_char const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return value_ >= rhs.value_;
   }
-
-#define NCURSES_CPP_ASSIGNMENT_ATTRS(op)                                       \
-  NCURSES_CPP_CONSTEXPR_14 curs_char &operator op##=(attr_flags const &rhs)    \
-      NCURSES_CPP_NOEXCEPT {                                                   \
-    value_ op## = static_cast<attr_flags::mask_type>(rhs);                     \
-    return *this;                                                              \
+  NCURSES_CPP_CONSTEXPR bool
+  operator==(curs_char const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return value_ == rhs.value_;
   }
-
-#define NCURSES_CPP_BITWISE_COLORS(op)                                         \
-  NCURSES_CPP_CONSTEXPR curs_char operator op(color_pair const &rhs)           \
-      const NCURSES_CPP_NOEXCEPT {                                             \
-    return curs_char(value_ op static_cast<color_pair::value_type>(rhs));      \
+  NCURSES_CPP_CONSTEXPR bool
+  operator!=(curs_char const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return value_ != rhs.value_;
   }
 
-#define NCURSES_CPP_ASSIGNMENT_COLORS(op)                                      \
-  NCURSES_CPP_CONSTEXPR_14 curs_char &operator op##=(color_pair const &rhs)    \
-      NCURSES_CPP_NOEXCEPT {                                                   \
-    value_ op## = static_cast<color_pair::value_type>(rhs);                    \
-    return *this;                                                              \
+  // bitwise operators with attr
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator&(attr rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ &
+                     static_cast<std ::underlying_type<attr>::type>(rhs));
   }
-
-#define NCURSES_CPP_BITWISE_FATTRS(op)                                         \
-  NCURSES_CPP_CONSTEXPR curs_char operator op(full_attrs const &rhs)           \
-      const NCURSES_CPP_NOEXCEPT {                                             \
-    return curs_char(value_ op static_cast<full_attrs::value_type>(rhs));      \
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator|(attr rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ |
+                     static_cast<std ::underlying_type<attr>::type>(rhs));
   }
-
-#define NCURSES_CPP_ASSIGNMENT_FATTRS(op)                                      \
-  NCURSES_CPP_CONSTEXPR_14 curs_char &operator op##=(full_attrs const &rhs)    \
-      NCURSES_CPP_NOEXCEPT {                                                   \
-    value_ op## = static_cast<full_attrs::value_type>(rhs);                    \
-    return *this;                                                              \
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator^(attr rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ ^
+                     static_cast<std ::underlying_type<attr>::type>(rhs));
   }
 
-  NCURSES_CPP_RELATIONAL(<)
-  NCURSES_CPP_RELATIONAL(<=)
-  NCURSES_CPP_RELATIONAL(>)
-  NCURSES_CPP_RELATIONAL(>=)
-  NCURSES_CPP_RELATIONAL(==)
-  NCURSES_CPP_RELATIONAL(!=)
-
-  NCURSES_CPP_BITWISE_ATTR(&)
-  NCURSES_CPP_BITWISE_ATTR(|)
-  NCURSES_CPP_BITWISE_ATTR(^)
-
-  NCURSES_CPP_BITWISE_ATTRS(&)
-  NCURSES_CPP_BITWISE_ATTRS(|)
-  NCURSES_CPP_BITWISE_ATTRS(^)
+  // bitwise operators with attr_flags
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator&(attr_flags const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ & static_cast<attr_flags ::mask_type>(rhs));
+  }
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator|(attr_flags const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ | static_cast<attr_flags ::mask_type>(rhs));
+  }
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator^(attr_flags const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ ^ static_cast<attr_flags ::mask_type>(rhs));
+  }
 
-  NCURSES_CPP_BITWISE_COLORS(&)
-  NCURSES_CPP_BITWISE_COLORS(|)
-  NCURSES_CPP_BITWISE_COLORS(^)
+  // bitwise operators with color_pair
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator&(color_pair const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ & static_cast<color_pair ::value_type>(rhs));
+  }
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator|(color_pair const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ | static_cast<color_pair ::value_type>(rhs));
+  }
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator^(color_pair const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ ^ static_cast<color_pair ::value_type>(rhs));
+  }
 
-  NCURSES_CPP_BITWISE_FATTRS(&)
-  NCURSES_CPP_BITWISE_FATTRS(|)
-  NCURSES_CPP_BITWISE_FATTRS(^)
+  // bitwise operators with full_attrs
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator&(full_attrs const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ & static_cast<full_attrs ::value_type>(rhs));
+  }
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator|(full_attrs const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ | static_cast<full_attrs ::value_type>(rhs));
+  }
+  NCURSES_CPP_CONSTEXPR curs_char
+  operator^(full_attrs const &rhs) const NCURSES_CPP_NOEXCEPT {
+    return curs_char(value_ ^ static_cast<full_attrs ::value_type>(rhs));
+  }
 
-  NCURSES_CPP_ASSIGNMENT_ATTR(&)
-  NCURSES_CPP_ASSIGNMENT_ATTR(|)
-  NCURSES_CPP_ASSIGNMENT_ATTR(^)
+  // assignment with attr
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator&=(attr rhs) NCURSES_CPP_NOEXCEPT {
+    value_ &= static_cast<std ::underlying_type<attr>::type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator|=(attr rhs) NCURSES_CPP_NOEXCEPT {
+    value_ |= static_cast<std ::underlying_type<attr>::type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator^=(attr rhs) NCURSES_CPP_NOEXCEPT {
+    value_ ^= static_cast<std ::underlying_type<attr>::type>(rhs);
+    return *this;
+  }
 
-  NCURSES_CPP_ASSIGNMENT_ATTRS(&)
-  NCURSES_CPP_ASSIGNMENT_ATTRS(|)
-  NCURSES_CPP_ASSIGNMENT_ATTRS(^)
+  // assignment with attr_flags
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator&=(attr_flags const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ &= static_cast<attr_flags ::mask_type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator|=(attr_flags const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ |= static_cast<attr_flags ::mask_type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator^=(attr_flags const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ ^= static_cast<attr_flags ::mask_type>(rhs);
+    return *this;
+  }
 
-  NCURSES_CPP_ASSIGNMENT_COLORS(&)
-  NCURSES_CPP_ASSIGNMENT_COLORS(|)
-  NCURSES_CPP_ASSIGNMENT_COLORS(^)
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator&=(color_pair const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ &= static_cast<color_pair ::value_type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator|=(color_pair const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ |= static_cast<color_pair ::value_type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator^=(color_pair const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ ^= static_cast<color_pair ::value_type>(rhs);
+    return *this;
+  }
 
-  NCURSES_CPP_ASSIGNMENT_FATTRS(&)
-  NCURSES_CPP_ASSIGNMENT_FATTRS(|)
-  NCURSES_CPP_ASSIGNMENT_FATTRS(^)
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator&=(full_attrs const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ &= static_cast<full_attrs ::value_type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator|=(full_attrs const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ |= static_cast<full_attrs ::value_type>(rhs);
+    return *this;
+  }
+  NCURSES_CPP_CONSTEXPR_14 curs_char &
+  operator^=(full_attrs const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ ^= static_cast<full_attrs ::value_type>(rhs);
+    return *this;
+  }
 
   NCURSES_CPP_CONSTEXPR bool operator!() const NCURSES_CPP_NOEXCEPT {
     return !value_;
@@ -141,6 +194,11 @@ public:
     return static_cast<char>(value_);
   }
 
+  explicit NCURSES_CPP_CONSTEXPR
+  operator value_type() const NCURSES_CPP_NOEXCEPT {
+    return value_;
+  }
+
 #if defined(NCURSES_CPP_CHAR_VALUE_AS_PUBLIC)
 public:
 #else
@@ -150,53 +208,175 @@ private:
 };
 
 // TODO:const otype& - link may be not as good as copy
-#define NPP_DEF_GLOB_OP(type, op, otype)                                       \
-  NCURSES_CPP_CONSTEXPR_INLINE type operator op(                               \
-      const otype &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {      \
-    return symbol.operator op(other);                                          \
-  }                                                                            \
-  NCURSES_CPP_CONSTEXPR_INLINE type operator op(const char &c,                 \
-                                                const otype &other) {          \
-    return curs_char(static_cast<curs_char::value_type>(c)                     \
-                         op static_cast<curs_char::value_type>(other));        \
-  }
-
-#define NPP_DEF_GLOB_OP_BOOL(op)                                               \
-  NCURSES_CPP_CONSTEXPR_INLINE bool operator op(const char &lhs,               \
-                                                const curs_char &rhs) {        \
-    return rhs.operator op(lhs);                                               \
-  }
-
-#define NPP_DEF_GLOB_OP_ATTR(op) NPP_DEF_GLOB_OP(curs_char, op, attr)
-#define NPP_DEF_GLOB_OP_ATTRS(op) NPP_DEF_GLOB_OP(curs_char, op, attr_flags)
-#define NPP_DEF_GLOB_OP_COLORS(op) NPP_DEF_GLOB_OP(curs_char, op, color_pair)
-#define NPP_DEF_GLOB_OP_FATTRS(op) NPP_DEF_GLOB_OP(curs_char, op, full_attrs)
 
 #if !defined(NCURSES_CPP_HAS_SPACESHIP_OPERATOR)
 // relational operators only needed for pre C++20
-NPP_DEF_GLOB_OP_BOOL(<)
-NPP_DEF_GLOB_OP_BOOL(<=)
-NPP_DEF_GLOB_OP_BOOL(>)
-NPP_DEF_GLOB_OP_BOOL(>=)
-NPP_DEF_GLOB_OP_BOOL(==)
-NPP_DEF_GLOB_OP_BOOL(!=)
+NCURSES_CPP_CONSTEXPR_INLINE bool
+operator<(const char &lhs, const curs_char &rhs) NCURSES_CPP_NOEXCEPT {
+  return rhs.operator>(lhs);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE bool
+operator<=(const char &lhs, const curs_char &rhs) NCURSES_CPP_NOEXCEPT {
+  return rhs.operator>=(lhs);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE bool
+operator>(const char &lhs, const curs_char &rhs) NCURSES_CPP_NOEXCEPT {
+  return rhs.operator<(lhs);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE bool
+operator>=(const char &lhs, const curs_char &rhs) NCURSES_CPP_NOEXCEPT {
+  return rhs.operator<=(lhs);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE bool
+operator==(const char &lhs, const curs_char &rhs) NCURSES_CPP_NOEXCEPT {
+  return rhs.operator==(lhs);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE bool
+operator!=(const char &lhs, const curs_char &rhs) NCURSES_CPP_NOEXCEPT {
+  return rhs.operator!=(lhs);
+}
 #endif
 
-NPP_DEF_GLOB_OP_ATTR(&)
-NPP_DEF_GLOB_OP_ATTR(|)
-NPP_DEF_GLOB_OP_ATTR(^)
-
-NPP_DEF_GLOB_OP_ATTRS(&)
-NPP_DEF_GLOB_OP_ATTRS(|)
-NPP_DEF_GLOB_OP_ATTRS(^)
-
-NPP_DEF_GLOB_OP_COLORS(&)
-NPP_DEF_GLOB_OP_COLORS(|)
-NPP_DEF_GLOB_OP_COLORS(^)
-
-NPP_DEF_GLOB_OP_FATTRS(&)
-NPP_DEF_GLOB_OP_FATTRS(|)
-NPP_DEF_GLOB_OP_FATTRS(^)
+// global attr + curs_char and char + attr -> curs_char operators
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator&(const attr &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator&(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator&(const char &c, const attr &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) &
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator|(const attr &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator|(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator|(const char &c, const attr &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) |
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator^(const attr &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator^(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator^(const char &c, const attr &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) ^
+                   static_cast<curs_char ::value_type>(other));
+}
+
+// global attr_flags + curs_char and char + attr_flags -> curs_char operators
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator&(
+    const attr_flags &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator&(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator&(const char &c, const attr_flags &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) &
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator|(
+    const attr_flags &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator|(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator|(const char &c, const attr_flags &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) |
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator^(
+    const attr_flags &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator^(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator^(const char &c, const attr_flags &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) ^
+                   static_cast<curs_char ::value_type>(other));
+}
+
+// global color_pair + curs_char and char + color_pair -> curs_char operators
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator&(
+    const color_pair &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator&(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator&(const char &c, const color_pair &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) &
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator|(
+    const color_pair &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator|(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator|(const char &c, const color_pair &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) |
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator^(
+    const color_pair &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator^(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator^(const char &c, const color_pair &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) ^
+                   static_cast<curs_char ::value_type>(other));
+}
+
+// global full_attrs + curs_char and char + full_attrs -> curs_char operators
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator&(
+    const full_attrs &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator&(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator&(const char &c, const full_attrs &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) &
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator|(
+    const full_attrs &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator|(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator|(const char &c, const full_attrs &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) |
+                   static_cast<curs_char ::value_type>(other));
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char operator^(
+    const full_attrs &other, curs_char const &symbol) NCURSES_CPP_NOEXCEPT {
+  return symbol.operator^(other);
+}
+
+NCURSES_CPP_CONSTEXPR_INLINE curs_char
+operator^(const char &c, const full_attrs &other) NCURSES_CPP_NOEXCEPT {
+  return curs_char(static_cast<curs_char ::value_type>(c) ^
+                   static_cast<curs_char ::value_type>(other));
+}
 
 } // namespace NCURSES_CPP_NAMESPACE
 
diff --git a/include/ncurses/utils/flags.hpp b/include/ncurses/utils/flags.hpp
index 69b7aa9..e379aaf 100644
--- a/include/ncurses/utils/flags.hpp
+++ b/include/ncurses/utils/flags.hpp
@@ -22,7 +22,7 @@ public:
       : mask_(static_cast<mask_type>(bit)) {}
 
   NCURSES_CPP_CONSTEXPR
-  flags(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT = default;
+  flags(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT : mask_(rhs.mask_) {}
 
   NCURSES_CPP_CONSTEXPR explicit flags(mask_type flags) : mask_(flags) {}
 
@@ -70,7 +70,10 @@ public:
 
   // assignment operators
   NCURSES_CPP_CONSTEXPR_14 flags<BitType> &
-  operator=(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT = default;
+  operator=(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT {
+    mask_ = rhs.mask_;
+    return *this;
+  }
 
   NCURSES_CPP_ASSIGNMENT(&)
   NCURSES_CPP_ASSIGNMENT(|)
diff --git a/include/ncurses/utils/multiflags.hpp b/include/ncurses/utils/multiflags.hpp
index e6af6a6..caed9af 100644
--- a/include/ncurses/utils/multiflags.hpp
+++ b/include/ncurses/utils/multiflags.hpp
@@ -37,8 +37,8 @@ public:
       : value_(static_cast<value_type>(flag)) {}
 
   NCURSES_CPP_CONSTEXPR
-  multiflags(multiflags<BitType, SecondBitType> const &rhs)
-      NCURSES_CPP_NOEXCEPT = default;
+  multiflags(multiflags<BitType, SecondBitType> const &rhs) NCURSES_CPP_NOEXCEPT
+      : value_(rhs.value_) {}
 
   NCURSES_CPP_CONSTEXPR explicit multiflags(value_type multiflags)
       : value_(multiflags) {}
@@ -88,9 +88,11 @@ public:
     return *this;                                                              \
   }
 
-  NCURSES_CPP_CONSTEXPR_14 multiflags<BitType, SecondBitType> &
-  operator=(multiflags<BitType, SecondBitType> const &rhs)
-      NCURSES_CPP_NOEXCEPT = default;
+  NCURSES_CPP_CONSTEXPR_14 multiflags<BitType, SecondBitType> &operator=(
+      multiflags<BitType, SecondBitType> const &rhs) NCURSES_CPP_NOEXCEPT {
+    value_ = rhs.value_;
+    return *this;
+  }
 
   NCURSES_CPP_ASSIGNMENT(&)
   NCURSES_CPP_ASSIGNMENT(|)
diff --git a/include/ncurses/window.hpp b/include/ncurses/window.hpp
index 7d26776..fc1c87c 100644
--- a/include/ncurses/window.hpp
+++ b/include/ncurses/window.hpp
@@ -1,15 +1,61 @@
 #ifndef INCLUDE_NCURSES_WINDOW_HPP_
 #define INCLUDE_NCURSES_WINDOW_HPP_
 
-#include <ncurses/utils/macros.hpp>
+#include <vector>
+
+#include <ncurses/utils/preamble.hpp>
 
 namespace NCURSES_CPP_NAMESPACE {
 
 class window {
 public:
-  window(int i);
+  // basic
+  window(int lines, int cols, int begin_y, int begin_x)
+      : win_(newwin(lines, cols, begin_y, begin_x)), parent_(nullptr) {}
+
+  window(window &parent, int lines, int cols, int begin_y, int begin_x)
+      : win_(subwin(parent.win_, lines, cols, begin_y, begin_x)),
+        parent_(&parent) {}
+
+  window(const window &other)
+      : win_(dupwin(other.win_)), parent_(other.parent_) {}
+
+  window(window &&other) : win_(other.win_) { other.win_ = nullptr; }
+
+  window &operator=(const window &other) {
+    delwin(win_);
+    win_ = dupwin(other.win_);
+    return *this;
+  }
+
+  window &operator=(window &&other) {
+    delwin(win_);
+    win_ = other.win_;
+    other.win_ = nullptr;
+    return *this;
+  }
+
+  explicit operator WINDOW *() const { return win_; }
+
+  virtual ~window() { free_window(); }
+
+  // interface
 
 private:
+  void add_subwin(window &win) { subwins_.push_back(&win); }
+  void free_window() {
+    if (win_) {
+      delwin(win_);
+      for (auto it : subwins_) {
+        it->free_window();
+      }
+    }
+    win_ = nullptr;
+  }
+
+  WINDOW *win_;
+  window *parent_;
+  std::vector<window *> subwins_;
 };
 
 } // namespace NCURSES_CPP_NAMESPACE