wxruby3 0.9.0.pre.rc.2 → 0.9.0

data/rakelib/lib/generate/analyzer.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 base interface Analyzer class
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 require 'monitor'
@@ -360,41 +363,47 @@ module WXRuby3
 
       def gen_enum_typemap(type)
         enum_scope = Extractor::EnumDef.enum_scope(type)
-        type_list = enum_scope.empty? ? [type] : [type, "#{enum_scope}::#{type}"]
-        rb_enum_name = rb_wx_name(type)
-        director.spec.map *type_list, as: rb_enum_name do
+        type_list = [type]
+        type_list << "#{enum_scope}::#{type.split('::').pop}" unless enum_scope.empty?
+        rb_enum_name = if !enum_scope.empty?
+                         "#{enum_scope}::#{rb_wx_name(type.split('::').pop)}"
+                       else
+                         rb_wx_name(type)
+                       end
+        STDERR.puts "*** #{director.spec.module_name}: defining type map for #{type_list} as: Wx::#{rb_enum_name}" if Director.trace?
+        director.spec.map *type_list, as: "Wx::#{rb_enum_name}" do
           map_in code: <<~__CODE
             int eval;
-            if (!wxRuby_GetEnumValue("#{type}", $input, eval))
+            if (!wxRuby_GetEnumValue("#{rb_enum_name}", $input, eval))
             {
               VALUE str = rb_inspect($input);
               rb_raise(rb_eArgError,
                        "Invalid enum class. Expected %s got %s.",
-                       "#{rb_enum_name}",
+                       "Wx::#{rb_enum_name}",
                        StringValuePtr(str));
             }
             $1 = static_cast<$1_type>(eval);
-            __CODE
+          __CODE
           map_out code: <<~__CODE
-            $result = wxRuby_GetEnumValueObject("#{type}", static_cast<int>($1));
-            __CODE
+            $result = wxRuby_GetEnumValueObject("#{rb_enum_name}", static_cast<int>($1));
+          __CODE
           map_typecheck precedence: 1, code: <<~__CODE
-            $1 = wxRuby_IsEnumValue("#{type}", $input);
-            __CODE
+            $1 = wxRuby_IsEnumValue("#{rb_enum_name}", $input);
+          __CODE
           map_directorin code: <<~__CODE
-            $input = wxRuby_GetEnumValueObject("#{type}", static_cast<int>($1));
+            $input = wxRuby_GetEnumValueObject("#{rb_enum_name}", static_cast<int>($1));
             if ($input == Qnil)
             {
               Swig::DirectorTypeMismatchException::raise(rb_eArgError, 
-                                                         "Invalid enum value for enum class #{rb_enum_name}.");
+                                                         "Invalid enum value for enum class Wx::#{rb_enum_name}.");
             }
           __CODE
           map_directorout code: <<~__CODE
             int eval;
-            if (!wxRuby_GetEnumValue("#{type}", $input, eval))
+            if (!wxRuby_GetEnumValue("#{rb_enum_name}", $input, eval))
             {
               Swig::DirectorTypeMismatchException::raise(rb_eTypeError, 
-                                                         "Invalid enum. Expected #{rb_enum_name}.");
+                                                         "Invalid enum. Expected Wx::#{rb_enum_name}.");
             }
             $result = static_cast<$1_type>(eval);
           __CODE
@@ -402,7 +411,7 @@ module WXRuby3
       end
 
       def gen_function_enum_typemaps(fndef, enum_maps)
-        if !(Extractor::MethodDef === fndef && fndef.is_ctor) &&
+        if !(Extractor::MethodDef === fndef && (fndef.is_ctor || fndef.type.nil?)) &&
               Extractor::EnumDef.enum?(fndef.type) &&
               !enum_maps.include?(fndef.type)
           gen_enum_typemap(fndef.type)
@@ -411,7 +420,7 @@ module WXRuby3
         fndef.parameters.each do |param|
           if Extractor::EnumDef.enum?(param.type) && !enum_maps.include?(param.type)
             gen_enum_typemap(param.type)
-            enum_maps << fndef.type
+            enum_maps << param.type
           end
         end
       end
@@ -554,10 +563,11 @@ module WXRuby3
                   if !mtdlist.include?(mtdsig)
                     # did we inherit a virtual method that was not proxied in the base
                     if mtdreg[:virtual] && !mtdreg[:proxy]
-                      # if we did NOT generate a wrapper override and we do not have the proxy suppressed we're in trouble
-                      if !cls_mtdreg.has_key?(mtdsig) && has_method_proxy?(item.name, mtdreg[:method])
-                        errors << "* ERROR: method #{mtdreg[:method].signature} is proxied without wrapper implementation in class #{item.name} but not proxied in base class #{base_name}!"
-                      elsif cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
+                      # # if we did NOT generate a wrapper override and we do not have the proxy suppressed we're in trouble
+                      # if !cls_mtdreg.has_key?(mtdsig) && has_method_proxy?(item.name, mtdreg[:method])
+                      #   warnings << "* WARNING: disabling proxy for virtual method #{mtdreg[:method].signature} without wrapper implementation in class #{item.name} since it is NOT proxied in base class #{base_name}!"
+                      # els
+                      if cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
                         # if this is not a custom extension and we do have an override wrapper and no proxy this is unnecessary code bloat
                         warnings << " * WARNING: Unnecessary override #{mtdreg[:method].signature} in class #{item.name} for non-proxied base in #{base_name}. Ignoring."
                         cls_mtdreg[mtdsig][:ignore] = true

data/rakelib/lib/generate/base.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 base Generator class
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 require_relative '../core/spec_helper'

data/rakelib/lib/generate/doc/aui_manager.yaml

@@ -0,0 +1,21 @@
+---
+:wxAuiManager:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /AddPane/
+          :replace: |
+            
+            ```ruby
+              @text1 = Wx::TextCtrl.new(self, -1)
+              @text2 = Wx::TextCtrl.new(self, -1)
+              @mgr.add_pane(@text1, Wx::LEFT, 'Pane Caption')
+              @mgr.add_pane(@text2, Wx::BOTTOM, 'Pane Caption')
+              @mgr.update
+            ```
+        - :pattern: !ruby/regexp /GetPane/
+          :replace: |
+            
+            ```ruby
+              @mgr.get_pane(@text1).float
+            ```

data/rakelib/lib/generate/doc/font.yaml

@@ -0,0 +1,29 @@
+---
+:wxFont.wxFont:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxFontInfo/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(Wx::FontInfo.new(10).bold().underlined())
+            ```
+        - :pattern: !ruby/regexp /wxFONTFAMILY_DEFAULT/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(10, Wx::FontFamily::FONTFAMILY_DEFAULT, 
+                                  Wx::FontStyle::FONTSTYLE_NORMAL, 
+                                  Wx::FontWeight::FONTWEIGHT_BOLD, true)
+            ```
+:wxFontInfo:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(Wx::FontInfo.new(12).face_name('Helvetica').italic())
+            ```

data/rakelib/lib/generate/doc/frame.yaml

@@ -0,0 +1,23 @@
+---
+:wxFrame:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::DEFAULT_FRAME_STYLE & ~(Wx::RESIZE_BORDER | Wx::MAXIMIZE_BOX)
+            ```
+:wxFrame.MSWGetTaskBarButton:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              if Wx::PLATFORM == 'WXMSW'
+                #...
+              end
+            ```

data/rakelib/lib/generate/doc/fs_file.yaml

@@ -0,0 +1,11 @@
+---
+:wxFSFile.wxFSFile:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /It is seldom used by the application programmer/
+          :replace: ''
+
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

data/rakelib/lib/generate/doc/gdi_common.yaml

@@ -0,0 +1,36 @@
+---
+:wxPoint.SetDefaults:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              if !pos.is_fully_specified
+                pos.set_defaults(get_default_position)
+              end
+            ```
+:wxPoint.wxPoint:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              real_point = ...
+              p = Wx::Point.new(real_point.x.round, real_point.y.round)
+            ```
+:wxSize.SetDefaults:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              if !size.is_fully_specified
+                size.set_defaults(get_default_size)
+              end
+            ```

data/rakelib/lib/generate/doc/graphics_context.yaml

@@ -0,0 +1,34 @@
+---
+:wxGraphicsContext:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              class MyCanvas < Wx::ScrolledWindow
+            
+                def on_paint(event)
+                   # Create paint DC
+                   self.paint do |dc|
+                     # Create graphics context from it
+                     Wx::GraphicsContext.draw_on(dc) do |gc|
+                         # make a path that contains a circle and some lines
+                         gc.set_pen(Wx::RED_PEN)
+                         path = gc.create_path
+                         path.add_circle(50.0, 50.0, 50.0)
+                         path.move_to_point(0.0, 50.0)
+                         path.add_line_to_point(100.0, 50.0)
+                         path.move_to_point(50.0, 0.0)
+                         path.add_line_to_point(50.0, 100.0)
+                         path.close_sub_path
+                         path.add_rectangle(25.0, 25.0, 50.0, 50.0)
+                  
+                         gc.stroke_path(path)
+                      end
+                    end
+                  end
+                end
+              end
+            ```

data/rakelib/lib/generate/doc/grid_cell_attr.yaml

@@ -0,0 +1,21 @@
+---
+:wxGridCellAttr.GetNonDefaultAlignment:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              h_align, v_align = attr.get_non_default_alignment
+              h_align = Wx::ALIGN_RIGHT if h_align == Wx::ALIGN_INVALID
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /Unlike\s.*\{Wx::Alignment::ALIGN_INVALID\}\./
+        :subst: 'Unlike {Wx::GRID::GridCellAttr#get_alignment} this function only returns hAlign and vAlign if this attribute does define a non-default alignment. Otherwise the returned value will be {Wx::ALIGN_INVALID}.'
+:wxGridCellAttr.GetAlignment:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /Notice\s.*desirable\./
+        :subst: 'Notice that valid hAlign and vAlign values (default or non-default) are always returned by this function, use {Wx::GRID::GridCellAttr#get_non_default_alignment} if this is not desirable.'

data/rakelib/lib/generate/doc/grid_ctrl.yaml

@@ -0,0 +1,25 @@
+---
+:wxGrid.GetRowGridLinePen:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MidiGrid < Wx::GRID::Grid
+            
+                # ...
+            
+                # in a grid displaying music notation, use a solid black pen between
+                # octaves (C0=row 127, C1=row 115 etc.)
+                def get_row_grid_line_pen(row)
+                  if row % 12 == 7 
+                    Wx::Pen.new(Wx::BLACK, 1, Wx::PENSTYLE_SOLID)
+                  else
+                    get_default_grid_line_pen
+                  end
+                end
+            
+              end
+            ```

data/rakelib/lib/generate/doc/gui_event_loop.yaml

@@ -0,0 +1,12 @@
+---
+:wxGUIEventLoop.Dispatch:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              while evt_loop.pending
+                evt_loop.dispatch
+            ```

data/rakelib/lib/generate/doc/help_controller.yaml

@@ -0,0 +1,24 @@
+---
+:wxHelpController.SetViewer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              @help.set_viewer('kdehelp')
+              @help.set_viewer('gnome-help-browser')
+              @help.set_viewer('netscape', Wx::HELP_NETSCAPE)
+            ```
+:wxHelpController:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Note\s+that\s+if\s+you\s+use\s+\.zip.*application\s+initialization:/
+          :subst: 'Note that in Ruby the required filesystem handlers for .zip or .htb books are always loaded.'
+        - :pattern: !ruby/regexp / or\s+nothing\s+will\s+be\s+shown\s+in\s+your\s+help\s+window./
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

data/rakelib/lib/generate/doc/html_cell.yaml

@@ -0,0 +1,11 @@
+---
+:wxHtmlContainerCell.SetWidthFloat.w:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_width_float(-50, Wx::HTML::HTML_UNITS_PIXELS)
+            ```

data/rakelib/lib/generate/doc/html_help_controller.yaml

@@ -0,0 +1,23 @@
+---
+:wxHtmlHelpController.AddBook:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              add_book('help.zip')
+            ```
+:wxHtmlHelpController.SetViewer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              @help.set_viewer('kdehelp')
+              @help.set_viewer('gnome-help-browser')
+              @help.set_viewer('netscape', Wx::HELP_NETSCAPE)
+            ```

data/rakelib/lib/generate/doc/html_help_window.yaml

@@ -0,0 +1,21 @@
+---
+:wxHtmlHelpWindow:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # @embeddedHelpWindow is a wxHtmlHelpWindow
+              # @embeddedHtmlHelp is a wxHtmlHelpController
+              #   
+              # Create embedded HTML Help window
+              @embeddedHelpWindow = Wx::HTML::HtmlHelpWindow.new
+              @embeddedHtmlHelp.use_config(config, rootPath) # Set your own config object here
+              @embeddedHtmlHelp.set_help_window(@embeddedHelpWindow)
+              @embeddedHelpWindow.create(self, Wx::ID_ANY, 
+                                         size: get_client_size,
+                                         style: Wx::TAB_TRAVERSAL|Wx::BORDER_NONE)
+              @embeddedHtmlHelp.add_book('doc.zip')
+            ```

data/rakelib/lib/generate/doc/html_window.yaml

@@ -0,0 +1,47 @@
+---
+:wxHtmlFilter.CanRead:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFilter < Wx::HTML::HtmlFilter
+                # ...
+            
+                def can_read(file)
+                  file.get_mime_type == 'application/x-ugh'
+                end
+            
+                # ...
+              end
+            ```
+:wxHtmlFilter.ReadFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFilter < Wx::HTML::HtmlFilter
+                # ...
+            
+                def read_file(file)
+                  '<html><body><img src="' + file.get_location + '"></body></html>'
+                end
+            
+                # ...
+              end
+            ```
+:wxHtmlWindow.SetPage:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              htmlwin.set_page('<html><body>Hello, world!</body></html>')
+            ```

data/rakelib/lib/generate/doc/icon.yaml

@@ -0,0 +1,11 @@
+---
+:wxIcon.GetIcon:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              get_icon(Wx::Size.new(size,size))
+            ```

data/rakelib/lib/generate/doc/image.yaml

@@ -0,0 +1,87 @@
+---
+:wxImage.Scale:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              # get the bitmap from somewhere
+              bmp = ...
+              
+              # rescale it to have size of 32*32
+              if bmp.width != 32 || bmp.height != 32
+                 image = bmp.convert_to_image
+                 bmp = Wx::Bitmap.new(image.scale(32, 32))
+              
+                 # another possibility:
+                 image.rescale(32, 32)
+                 bmp = image.to_bitmap
+              end
+            ```
+:wxImage.LoadFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              hotspot_x = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_X)
+              hotspot_y = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y)
+            ```
+:wxImage.SaveFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_X, hotspot_x)
+              image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y, hotspot_y)
+            ```
+:wxImage.SetLoadFlags:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              image = Wx::Image.new
+              image.set_load_flags(image.get_load_flags & ~Wx::Image::Load_Verbose)
+              image.load_file(...)
+            ```
+:wxImage.wxImage:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              hotspot_x = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_X)
+              hotspot_y = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y)
+            ```
+:wxImage.GetImageExtWildcard:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              Wx::FileDialog(self, 'Choose Image', Dir.getwd, '',
+                             'Image Files ' + Wx::Image.get_image_ext_wildcard,
+                             Wx::FD_OPEN) do |file_dlg|
+                # ...
+              end
+            ```
+:wxImage:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /To\s+use\s+other\s+image\s+formats,.*or\s+call\s+.*\./
+          :subst: 'In wxRuby all image handlers are loaded by default at startup by {init_all_image_handlers}.'

data/rakelib/lib/generate/doc/keyboard_state.yaml

@@ -0,0 +1,19 @@
+---
+:wxKeyboardState.GetModifiers:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /ControlDown/
+          :replace: |
+
+            ```ruby
+              if control_down && !alt_down && !shift_down && !meta_down
+                ... handle Ctrl-XXX ...
+            ```
+        - :pattern: !ruby/regexp /GetModifiers/
+          :replace: |
+
+            ```ruby
+              if get_modifiers == Wx::MOD_CONTROL
+                ... handle Ctrl-XXX ...
+            ```

data/rakelib/lib/generate/doc/list_ctrl.yaml

@@ -0,0 +1,77 @@
+---
+:wxListCtrl.GetNextItem:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              item = -1
+              while (item = list_ctrl.get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED)) != -1
+                # item is selected - do whatever is needed with it
+                Wx.log_message("Item #{item} is selected.")
+              end
+            
+              # alternatively in wxRuby you could do
+              list_ctrl.each_selected do |item|
+                Wx.log_message("Item #{item} is selected.")
+              end
+            ```
+:wxListCtrl.SetItemState:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /item.*wxLIST_STATE_SELECTED.*wxLIST_STATE_SELECTED/
+          :replace: |
+
+            ```ruby
+              list.set_item_state(item, Wx::LIST_STATE_SELECTED, Wx::LIST_STATE_SELECTED)
+            ```
+        - :pattern: !ruby/regexp /item.*0.*wxLIST_STATE_SELECTED/
+          :replace: |
+
+            ```ruby
+              list.set_item_state(item, 0, Wx::LIST_STATE_SELECTED)
+            ```
+:wxListCtrl.GetUpdatedAscendingSortIndicator:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              class MyListCtrl
+            
+                def on_col_click(event)
+                  col = event.column
+                  if col == -1
+                     return # clicked outside any column.
+              
+                  ascending = get_updated_ascending_sort_indicator(col)
+                  sort_items(ascending) { |itm1_data, itm2_data, data| ... }
+                  show_sort_indicator(col, ascending)
+                end
+            
+              end
+            ```
+:wxListCtrl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              list = Wx::ListCtrl.new(...)
+              3.times { |i| list.insert_column(i, "Column #{i}") }
+              
+              order = [2, 0, 1]
+              list.set_columns_order(order)
+              
+              # now list.get_columns_order() will return order and
+              # list.get_column_index_from_order(n) will return order[n] and
+              # list.get_column_order() will return 1, 2 and 0 for the column 0,
+              # 1 and 2 respectively
+            ```