diff --git a/misc/cpp/extract_scoped.rb b/misc/cpp/extract_scoped.rb
new file mode 100644
index 000000000..faea36c58
--- /dev/null
+++ b/misc/cpp/extract_scoped.rb
@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = 2
+
+INDENT = ' ' * 4
+
+puts <<EOT
+#pragma once
+
+#include "imgui.h"
+
+namespace ImScoped
+{
+#{INDENT}#define IMGUI_DELETE_MOVE_COPY(Base)#{INDENT}                         \\
+#{INDENT}#{INDENT}Base(Base&&) = delete;                /* Move not allowed */ \\
+#{INDENT}#{INDENT}Base &operator=(Base&&) = delete;     /* "" */               \\
+#{INDENT}#{INDENT}Base(const Base&) = delete;           /* Copy not allowed */ \\
+#{INDENT}#{INDENT}Base& operator=(const Base&) = delete /* "" */
+
+EOT
+
+class WrapperClass
+  attr_reader :name, :class_name, :state_var
+
+  def initialize(m)
+    @name = m[:name]
+
+    @class_name = case @name
+                  when 'Begin'
+                    'Window'
+                  when /^Begin(.*)$/
+                    $1
+                  when /^Push(.*)$/
+                    $1
+                  else
+                    m[:name]
+                  end
+
+    @state_var = case @name
+                 when 'Begin', 'BeginChild'
+                   'IsContentVisible'
+                 else
+                   'IsOpen' if m[:type] == %w{bool}
+                 end
+
+    puts <<EOT
+#{INDENT}struct #{@class_name}
+#{INDENT}{
+EOT
+    if @state_var
+      puts "#{INDENT * 2}#{m[:type].join('')} #{@state_var};"
+      puts
+    end
+  end
+
+  def close
+    print "#{INDENT * 2}~#{@class_name}() { "
+    print case @name
+          when 'Begin' then 'ImGui::End();'
+          when 'BeginChild' then 'ImGui::EndChild();'
+          when 'BeginChildFrame' then 'ImGui::EndChildFrame();'
+          when /^BeginPopup/ then "if (#{@state_var}) ImGui::EndPopup();"
+          when /^Begin(.*)/
+            body = "ImGui::End#{$1}();"
+            body = "if (#{@state_var}) " + body if @state_var
+            body
+          when /^TreeNode/ then "if (#{@state_var}) ImGui::TreePop();"
+          when 'TreePush' then 'ImGui::TreePop();'
+          when /^Push(.*)/ then "ImGui::Pop#{$1}();"
+          else fail "Don't know what pop body to use for #{@name}"
+          end
+    puts " }"
+
+    if @state_var
+      puts
+      puts "#{INDENT * 2}explicit operator bool() const { return #{@state_var}; }"
+    end
+
+    puts
+    puts "#{INDENT * 2}IMGUI_DELETE_MOVE_COPY(#{@class_name});"
+    puts "#{INDENT}};"
+  end
+end
+
+def is_space(token)
+  token =~ /^\s+/
+end
+
+def first_non_space(tokens)
+  tokens.find { |token| !is_space(token) }
+end
+
+def skip_spaces(tokens)
+  tokens.shift while is_space(tokens.first)
+end
+
+def parse_until(tokens, stop_token)
+  parsed = []
+
+  while first_non_space(tokens) != stop_token
+    token = tokens.shift
+    fail "End of tokens while looking for #{stop_token}" unless token
+    parsed << token
+  end
+  skip_spaces(tokens)
+  tokens.shift
+
+  parsed
+end
+
+def chop_space(tokens)
+  tokens.pop if is_space(tokens.last)
+end
+
+def parse_method(line)
+  m = {}
+
+  tokens = line.scan(/\w+|\s+|\.\.\.|\/\/.*$|./)
+  skip_spaces(tokens)
+
+  return nil unless tokens.shift == 'IMGUI_API'
+  skip_spaces(tokens)
+
+  type_and_name = parse_until(tokens, '(')
+  m[:name] = type_and_name.pop
+  chop_space(type_and_name)
+  m[:type] = type_and_name
+
+  return nil unless m[:name].match(/^(Begin|Push|TreeNode)/)
+
+  m[:args] = [[]]
+  m[:argnames] = []
+  paren_level = 0
+  in_default = false
+  loop do
+    token = tokens.shift
+    fail "End of tokens while parsing argument list" unless token
+
+    case token
+    when '('
+      paren_level+= 1
+    when ')'
+      break if paren_level == 0
+      paren_level-= 1
+    when ','
+      if paren_level == 0
+        m[:args] << []
+        in_default = false
+        next
+      end
+    end
+
+    if paren_level == 0 && !in_default
+      next_non_space = first_non_space(tokens)
+
+      if next_non_space == ')' || next_non_space == ',' || next_non_space == '='
+        m[:argnames] << token
+        in_default = (next_non_space == '=')
+      end
+    end
+
+    m[:args][-1] << token
+  end
+
+  m[:attrs] = parse_until(tokens, ';')
+
+  skip_spaces(tokens)
+  m[:rest] = tokens
+
+  m
+end
+
+current_class = nil
+
+header_file = File.open("../../imgui.h")
+header_file.each_line do |line|
+  break if line.match(/^}\s*\/\/\s*namespace ImGui$/i)
+
+  m = parse_method(line)
+  next unless m
+
+  next unless m[:name].match(/^(Begin|Push|Tree)/)
+
+  $stderr.puts m.inspect if $-d
+
+  # Check for obsolete
+  if m[:name] == 'Begin' &&
+      (m[:argnames] == %w{name p_open size_on_first_use bg_alpha_override flags} ||
+       m[:argnames] == %w{items_count items_height})
+    next
+  end
+
+  fail "Return value #{m[:type]} is not bool or void" unless [%w{bool}, %w{void}].include?(m[:type])
+
+  if !current_class || current_class.name != m[:name]
+    if current_class
+      current_class.close
+      puts
+    end
+
+    current_class = WrapperClass.new(m)
+  end
+
+  shift_index = false
+  attrs = m[:attrs].map do |attr|
+    case attr
+    when /^IM_FMT(ARGS|LIST)$/
+      shift_index = true
+    when /^\d+/
+      if shift_index
+        attr = (attr.to_i + 1).to_s
+        shift_index = false
+      end
+    end
+    attr
+  end.join('')
+
+  args = m[:args].map { |argparts| argparts.join('') }.join(',')
+  print "#{INDENT * 2}#{current_class.class_name}(#{args})#{attrs} {"
+
+  use_varargs = false
+  if m[:argnames].last == '...'
+    m[:argnames][-1] = 'ap'
+    use_varargs = true
+    print " va_list ap; va_start(ap, fmt);"
+  end
+
+  if m[:name] =~ /^TreeNodeEx/ && m[:argnames].include?('flags')
+    print " IM_ASSERT(!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen));"
+  end
+
+  print " #{current_class.state_var} =" if current_class.state_var
+
+  print " ImGui::#{m[:name]}"
+  print 'V' if use_varargs
+  print "(#{m[:argnames].join(', ')}); "
+  print 'va_end(ap); ' if use_varargs
+
+  puts '}'
+end
+
+current_class.close if current_class
+
+puts <<EOT
+
+#{INDENT}#undef IMGUI_DELETE_MOVE_COPY
+
+} // namespace ImScoped
+EOT
diff --git a/misc/cpp/imgui_scoped.h b/misc/cpp/imgui_scoped.h
new file mode 100644
index 000000000..cd872b187
--- /dev/null
+++ b/misc/cpp/imgui_scoped.h
@@ -0,0 +1,331 @@
+#pragma once
+
+#include "imgui.h"
+
+namespace ImScoped
+{
+    #define IMGUI_DELETE_MOVE_COPY(Base)                             \
+        Base(Base&&) = delete;                /* Move not allowed */ \
+        Base &operator=(Base&&) = delete;     /* "" */               \
+        Base(const Base&) = delete;           /* Copy not allowed */ \
+        Base& operator=(const Base&) = delete /* "" */
+
+    struct Window
+    {
+        bool IsContentVisible;
+
+        Window(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0) { IsContentVisible = ImGui::Begin(name, p_open, flags); }
+        ~Window() { ImGui::End(); }
+
+        explicit operator bool() const { return IsContentVisible; }
+
+        IMGUI_DELETE_MOVE_COPY(Window);
+    };
+
+    struct Child
+    {
+        bool IsContentVisible;
+
+        Child(const char* str_id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags flags = 0) { IsContentVisible = ImGui::BeginChild(str_id, size, border, flags); }
+        Child(ImGuiID id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags flags = 0) { IsContentVisible = ImGui::BeginChild(id, size, border, flags); }
+        ~Child() { ImGui::EndChild(); }
+
+        explicit operator bool() const { return IsContentVisible; }
+
+        IMGUI_DELETE_MOVE_COPY(Child);
+    };
+
+    struct Font
+    {
+        Font(ImFont* font) { ImGui::PushFont(font); }
+        ~Font() { ImGui::PopFont(); }
+
+        IMGUI_DELETE_MOVE_COPY(Font);
+    };
+
+    struct StyleColor
+    {
+        StyleColor(ImGuiCol idx, ImU32 col) { ImGui::PushStyleColor(idx, col); }
+        StyleColor(ImGuiCol idx, const ImVec4& col) { ImGui::PushStyleColor(idx, col); }
+        ~StyleColor() { ImGui::PopStyleColor(); }
+
+        IMGUI_DELETE_MOVE_COPY(StyleColor);
+    };
+
+    struct StyleVar
+    {
+        StyleVar(ImGuiStyleVar idx, float val) { ImGui::PushStyleVar(idx, val); }
+        StyleVar(ImGuiStyleVar idx, const ImVec2& val) { ImGui::PushStyleVar(idx, val); }
+        ~StyleVar() { ImGui::PopStyleVar(); }
+
+        IMGUI_DELETE_MOVE_COPY(StyleVar);
+    };
+
+    struct ItemWidth
+    {
+        ItemWidth(float item_width) { ImGui::PushItemWidth(item_width); }
+        ~ItemWidth() { ImGui::PopItemWidth(); }
+
+        IMGUI_DELETE_MOVE_COPY(ItemWidth);
+    };
+
+    struct TextWrapPos
+    {
+        TextWrapPos(float wrap_pos_x = 0.0f) { ImGui::PushTextWrapPos(wrap_pos_x); }
+        ~TextWrapPos() { ImGui::PopTextWrapPos(); }
+
+        IMGUI_DELETE_MOVE_COPY(TextWrapPos);
+    };
+
+    struct AllowKeyboardFocus
+    {
+        AllowKeyboardFocus(bool allow_keyboard_focus) { ImGui::PushAllowKeyboardFocus(allow_keyboard_focus); }
+        ~AllowKeyboardFocus() { ImGui::PopAllowKeyboardFocus(); }
+
+        IMGUI_DELETE_MOVE_COPY(AllowKeyboardFocus);
+    };
+
+    struct ButtonRepeat
+    {
+        ButtonRepeat(bool repeat) { ImGui::PushButtonRepeat(repeat); }
+        ~ButtonRepeat() { ImGui::PopButtonRepeat(); }
+
+        IMGUI_DELETE_MOVE_COPY(ButtonRepeat);
+    };
+
+    struct Group
+    {
+        Group() { ImGui::BeginGroup(); }
+        ~Group() { ImGui::EndGroup(); }
+
+        IMGUI_DELETE_MOVE_COPY(Group);
+    };
+
+    struct ID
+    {
+        ID(const char* str_id) { ImGui::PushID(str_id); }
+        ID(const char* str_id_begin, const char* str_id_end) { ImGui::PushID(str_id_begin, str_id_end); }
+        ID(const void* ptr_id) { ImGui::PushID(ptr_id); }
+        ID(int int_id) { ImGui::PushID(int_id); }
+        ~ID() { ImGui::PopID(); }
+
+        IMGUI_DELETE_MOVE_COPY(ID);
+    };
+
+    struct Combo
+    {
+        bool IsOpen;
+
+        Combo(const char* label, const char* preview_value, ImGuiComboFlags flags = 0) { IsOpen = ImGui::BeginCombo(label, preview_value, flags); }
+        ~Combo() { if (IsOpen) ImGui::EndCombo(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(Combo);
+    };
+
+    struct TreeNode
+    {
+        bool IsOpen;
+
+        TreeNode(const char* label) { IsOpen = ImGui::TreeNode(label); }
+        TreeNode(const char* str_id, const char* fmt, ...) IM_FMTARGS(3) { va_list ap; va_start(ap, fmt); IsOpen = ImGui::TreeNodeV(str_id, fmt, ap); va_end(ap); }
+        TreeNode(const void* ptr_id, const char* fmt, ...) IM_FMTARGS(3) { va_list ap; va_start(ap, fmt); IsOpen = ImGui::TreeNodeV(ptr_id, fmt, ap); va_end(ap); }
+        ~TreeNode() { if (IsOpen) ImGui::TreePop(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(TreeNode);
+    };
+
+    struct TreeNodeV
+    {
+        bool IsOpen;
+
+        TreeNodeV(const char* str_id, const char* fmt, va_list args) IM_FMTLIST(3) { IsOpen = ImGui::TreeNodeV(str_id, fmt, args); }
+        TreeNodeV(const void* ptr_id, const char* fmt, va_list args) IM_FMTLIST(3) { IsOpen = ImGui::TreeNodeV(ptr_id, fmt, args); }
+        ~TreeNodeV() { if (IsOpen) ImGui::TreePop(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(TreeNodeV);
+    };
+
+    struct TreeNodeEx
+    {
+        bool IsOpen;
+
+        TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags = 0) { IM_ASSERT(!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)); IsOpen = ImGui::TreeNodeEx(label, flags); }
+        TreeNodeEx(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_FMTARGS(4) { va_list ap; va_start(ap, fmt); IM_ASSERT(!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)); IsOpen = ImGui::TreeNodeExV(str_id, flags, fmt, ap); va_end(ap); }
+        TreeNodeEx(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_FMTARGS(4) { va_list ap; va_start(ap, fmt); IM_ASSERT(!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)); IsOpen = ImGui::TreeNodeExV(ptr_id, flags, fmt, ap); va_end(ap); }
+        ~TreeNodeEx() { if (IsOpen) ImGui::TreePop(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(TreeNodeEx);
+    };
+
+    struct TreeNodeExV
+    {
+        bool IsOpen;
+
+        TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args) IM_FMTLIST(4) { IM_ASSERT(!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)); IsOpen = ImGui::TreeNodeExV(str_id, flags, fmt, args); }
+        TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args) IM_FMTLIST(4) { IM_ASSERT(!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)); IsOpen = ImGui::TreeNodeExV(ptr_id, flags, fmt, args); }
+        ~TreeNodeExV() { if (IsOpen) ImGui::TreePop(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(TreeNodeExV);
+    };
+
+    struct MainMenuBar
+    {
+        bool IsOpen;
+
+        MainMenuBar() { IsOpen = ImGui::BeginMainMenuBar(); }
+        ~MainMenuBar() { if (IsOpen) ImGui::EndMainMenuBar(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(MainMenuBar);
+    };
+
+    struct MenuBar
+    {
+        bool IsOpen;
+
+        MenuBar() { IsOpen = ImGui::BeginMenuBar(); }
+        ~MenuBar() { if (IsOpen) ImGui::EndMenuBar(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(MenuBar);
+    };
+
+    struct Menu
+    {
+        bool IsOpen;
+
+        Menu(const char* label, bool enabled = true) { IsOpen = ImGui::BeginMenu(label, enabled); }
+        ~Menu() { if (IsOpen) ImGui::EndMenu(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(Menu);
+    };
+
+    struct Tooltip
+    {
+        Tooltip() { ImGui::BeginTooltip(); }
+        ~Tooltip() { ImGui::EndTooltip(); }
+
+        IMGUI_DELETE_MOVE_COPY(Tooltip);
+    };
+
+    struct Popup
+    {
+        bool IsOpen;
+
+        Popup(const char* str_id, ImGuiWindowFlags flags = 0) { IsOpen = ImGui::BeginPopup(str_id, flags); }
+        ~Popup() { if (IsOpen) ImGui::EndPopup(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(Popup);
+    };
+
+    struct PopupContextItem
+    {
+        bool IsOpen;
+
+        PopupContextItem(const char* str_id = NULL, int mouse_button = 1) { IsOpen = ImGui::BeginPopupContextItem(str_id, mouse_button); }
+        ~PopupContextItem() { if (IsOpen) ImGui::EndPopup(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(PopupContextItem);
+    };
+
+    struct PopupContextWindow
+    {
+        bool IsOpen;
+
+        PopupContextWindow(const char* str_id = NULL, int mouse_button = 1, bool also_over_items = true) { IsOpen = ImGui::BeginPopupContextWindow(str_id, mouse_button, also_over_items); }
+        ~PopupContextWindow() { if (IsOpen) ImGui::EndPopup(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(PopupContextWindow);
+    };
+
+    struct PopupContextVoid
+    {
+        bool IsOpen;
+
+        PopupContextVoid(const char* str_id = NULL, int mouse_button = 1) { IsOpen = ImGui::BeginPopupContextVoid(str_id, mouse_button); }
+        ~PopupContextVoid() { if (IsOpen) ImGui::EndPopup(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(PopupContextVoid);
+    };
+
+    struct PopupModal
+    {
+        bool IsOpen;
+
+        PopupModal(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0) { IsOpen = ImGui::BeginPopupModal(name, p_open, flags); }
+        ~PopupModal() { if (IsOpen) ImGui::EndPopup(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(PopupModal);
+    };
+
+    struct DragDropSource
+    {
+        bool IsOpen;
+
+        DragDropSource(ImGuiDragDropFlags flags = 0) { IsOpen = ImGui::BeginDragDropSource(flags); }
+        ~DragDropSource() { if (IsOpen) ImGui::EndDragDropSource(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(DragDropSource);
+    };
+
+    struct DragDropTarget
+    {
+        bool IsOpen;
+
+        DragDropTarget() { IsOpen = ImGui::BeginDragDropTarget(); }
+        ~DragDropTarget() { if (IsOpen) ImGui::EndDragDropTarget(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(DragDropTarget);
+    };
+
+    struct ClipRect
+    {
+        ClipRect(const ImVec2& clip_rect_min, const ImVec2& clip_rect_max, bool intersect_with_current_clip_rect) { ImGui::PushClipRect(clip_rect_min, clip_rect_max, intersect_with_current_clip_rect); }
+        ~ClipRect() { ImGui::PopClipRect(); }
+
+        IMGUI_DELETE_MOVE_COPY(ClipRect);
+    };
+
+    struct ChildFrame
+    {
+        bool IsOpen;
+
+        ChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags flags = 0) { IsOpen = ImGui::BeginChildFrame(id, size, flags); }
+        ~ChildFrame() { ImGui::EndChildFrame(); }
+
+        explicit operator bool() const { return IsOpen; }
+
+        IMGUI_DELETE_MOVE_COPY(ChildFrame);
+    };
+
+    #undef IMGUI_DELETE_MOVE_COPY
+
+} // namespace ImScoped