with GNATCOM.IInterface;

with GNATCOM.Errors;

package body MSHTML.IHTMLRuleStyle_Interface is

   procedure Initialize (This : in out IHTMLRuleStyle_Type) is
   begin
      Set_IID (This, IID_IHTMLRuleStyle);
   end Initialize;

   function Pointer (This : IHTMLRuleStyle_Type)
     return Pointer_To_IHTMLRuleStyle
   is
   begin
      return To_Pointer_To_IHTMLRuleStyle (Address (This));
   end Pointer;

   procedure Attach (This    : in out IHTMLRuleStyle_Type;
                     Pointer : in     Pointer_To_IHTMLRuleStyle)
   is
   begin
      Attach (This, GNATCOM.IInterface.To_Pointer_To_IUnknown
              (Pointer.all'Address));
   end Attach;

   procedure Put_fontFamily
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_fontFamily
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_fontFamily;

   function Get_fontFamily
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_fontFamily
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_fontFamily;

   procedure Put_fontStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_fontStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_fontStyle;

   function Get_fontStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_fontStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_fontStyle;

   procedure Put_fontVariant
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_fontVariant
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_fontVariant;

   function Get_fontVariant
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_fontVariant
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_fontVariant;

   procedure Put_fontWeight
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_fontWeight
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_fontWeight;

   function Get_fontWeight
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_fontWeight
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_fontWeight;

   procedure Put_fontSize
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_fontSize
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_fontSize;

   function Get_fontSize
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_fontSize
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_fontSize;

   procedure Put_font
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_font
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_font;

   function Get_font
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_font
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_font;

   procedure Put_color
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_color
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_color;

   function Get_color
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_color
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_color;

   procedure Put_background
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_background
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_background;

   function Get_background
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_background
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_background;

   procedure Put_backgroundColor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundColor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundColor;

   function Get_backgroundColor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundColor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundColor;

   procedure Put_backgroundImage
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundImage
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundImage;

   function Get_backgroundImage
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundImage
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundImage;

   procedure Put_backgroundRepeat
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundRepeat
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundRepeat;

   function Get_backgroundRepeat
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundRepeat
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundRepeat;

   procedure Put_backgroundAttachment
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundAttachment
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundAttachment;

   function Get_backgroundAttachment
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundAttachment
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundAttachment;

   procedure Put_backgroundPosition
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundPosition
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundPosition;

   function Get_backgroundPosition
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundPosition
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundPosition;

   procedure Put_backgroundPositionX
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundPositionX
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundPositionX;

   function Get_backgroundPositionX
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundPositionX
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundPositionX;

   procedure Put_backgroundPositionY
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_backgroundPositionY
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_backgroundPositionY;

   function Get_backgroundPositionY
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_backgroundPositionY
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_backgroundPositionY;

   procedure Put_wordSpacing
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_wordSpacing
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_wordSpacing;

   function Get_wordSpacing
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_wordSpacing
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_wordSpacing;

   procedure Put_letterSpacing
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_letterSpacing
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_letterSpacing;

   function Get_letterSpacing
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_letterSpacing
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_letterSpacing;

   procedure Put_textDecoration
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textDecoration
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_textDecoration;

   function Get_textDecoration
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textDecoration
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textDecoration;

   procedure Put_textDecorationNone
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT_BOOL)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textDecorationNone
         (Pointer (This),
          p));

   end Put_textDecorationNone;

   function Get_textDecorationNone
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT_BOOL
   is
       RetVal : aliased GNATCOM.Types.VARIANT_BOOL;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textDecorationNone
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textDecorationNone;

   procedure Put_textDecorationUnderline
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT_BOOL)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textDecorationUnderline
         (Pointer (This),
          p));

   end Put_textDecorationUnderline;

   function Get_textDecorationUnderline
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT_BOOL
   is
       RetVal : aliased GNATCOM.Types.VARIANT_BOOL;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textDecorationUnderline
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textDecorationUnderline;

   procedure Put_textDecorationOverline
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT_BOOL)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textDecorationOverline
         (Pointer (This),
          p));

   end Put_textDecorationOverline;

   function Get_textDecorationOverline
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT_BOOL
   is
       RetVal : aliased GNATCOM.Types.VARIANT_BOOL;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textDecorationOverline
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textDecorationOverline;

   procedure Put_textDecorationLineThrough
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT_BOOL)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textDecorationLineThrough
         (Pointer (This),
          p));

   end Put_textDecorationLineThrough;

   function Get_textDecorationLineThrough
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT_BOOL
   is
       RetVal : aliased GNATCOM.Types.VARIANT_BOOL;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textDecorationLineThrough
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textDecorationLineThrough;

   procedure Put_textDecorationBlink
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT_BOOL)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textDecorationBlink
         (Pointer (This),
          p));

   end Put_textDecorationBlink;

   function Get_textDecorationBlink
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT_BOOL
   is
       RetVal : aliased GNATCOM.Types.VARIANT_BOOL;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textDecorationBlink
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textDecorationBlink;

   procedure Put_verticalAlign
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_verticalAlign
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_verticalAlign;

   function Get_verticalAlign
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_verticalAlign
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_verticalAlign;

   procedure Put_textTransform
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textTransform
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_textTransform;

   function Get_textTransform
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textTransform
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textTransform;

   procedure Put_textAlign
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textAlign
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_textAlign;

   function Get_textAlign
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textAlign
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textAlign;

   procedure Put_textIndent
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_textIndent
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_textIndent;

   function Get_textIndent
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_textIndent
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_textIndent;

   procedure Put_lineHeight
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_lineHeight
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_lineHeight;

   function Get_lineHeight
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_lineHeight
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_lineHeight;

   procedure Put_marginTop
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_marginTop
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_marginTop;

   function Get_marginTop
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_marginTop
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_marginTop;

   procedure Put_marginRight
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_marginRight
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_marginRight;

   function Get_marginRight
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_marginRight
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_marginRight;

   procedure Put_marginBottom
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_marginBottom
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_marginBottom;

   function Get_marginBottom
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_marginBottom
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_marginBottom;

   procedure Put_marginLeft
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_marginLeft
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_marginLeft;

   function Get_marginLeft
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_marginLeft
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_marginLeft;

   procedure Put_margin
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_margin
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_margin;

   function Get_margin
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_margin
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_margin;

   procedure Put_paddingTop
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_paddingTop
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_paddingTop;

   function Get_paddingTop
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_paddingTop
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_paddingTop;

   procedure Put_paddingRight
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_paddingRight
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_paddingRight;

   function Get_paddingRight
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_paddingRight
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_paddingRight;

   procedure Put_paddingBottom
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_paddingBottom
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_paddingBottom;

   function Get_paddingBottom
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_paddingBottom
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_paddingBottom;

   procedure Put_paddingLeft
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_paddingLeft
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_paddingLeft;

   function Get_paddingLeft
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_paddingLeft
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_paddingLeft;

   procedure Put_padding
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_padding
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_padding;

   function Get_padding
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_padding
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_padding;

   procedure Put_border
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_border
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_border;

   function Get_border
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_border
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_border;

   procedure Put_borderTop
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderTop
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderTop;

   function Get_borderTop
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderTop
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderTop;

   procedure Put_borderRight
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderRight
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderRight;

   function Get_borderRight
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderRight
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderRight;

   procedure Put_borderBottom
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderBottom
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderBottom;

   function Get_borderBottom
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderBottom
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderBottom;

   procedure Put_borderLeft
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderLeft
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderLeft;

   function Get_borderLeft
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderLeft
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderLeft;

   procedure Put_borderColor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderColor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderColor;

   function Get_borderColor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderColor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderColor;

   procedure Put_borderTopColor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderTopColor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderTopColor;

   function Get_borderTopColor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderTopColor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderTopColor;

   procedure Put_borderRightColor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderRightColor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderRightColor;

   function Get_borderRightColor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderRightColor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderRightColor;

   procedure Put_borderBottomColor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderBottomColor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderBottomColor;

   function Get_borderBottomColor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderBottomColor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderBottomColor;

   procedure Put_borderLeftColor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderLeftColor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderLeftColor;

   function Get_borderLeftColor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderLeftColor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderLeftColor;

   procedure Put_borderWidth
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderWidth
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderWidth;

   function Get_borderWidth
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderWidth
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderWidth;

   procedure Put_borderTopWidth
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderTopWidth
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderTopWidth;

   function Get_borderTopWidth
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderTopWidth
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderTopWidth;

   procedure Put_borderRightWidth
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderRightWidth
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderRightWidth;

   function Get_borderRightWidth
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderRightWidth
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderRightWidth;

   procedure Put_borderBottomWidth
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderBottomWidth
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderBottomWidth;

   function Get_borderBottomWidth
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderBottomWidth
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderBottomWidth;

   procedure Put_borderLeftWidth
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderLeftWidth
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderLeftWidth;

   function Get_borderLeftWidth
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderLeftWidth
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderLeftWidth;

   procedure Put_borderStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderStyle;

   function Get_borderStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderStyle;

   procedure Put_borderTopStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderTopStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderTopStyle;

   function Get_borderTopStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderTopStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderTopStyle;

   procedure Put_borderRightStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderRightStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderRightStyle;

   function Get_borderRightStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderRightStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderRightStyle;

   procedure Put_borderBottomStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderBottomStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderBottomStyle;

   function Get_borderBottomStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderBottomStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderBottomStyle;

   procedure Put_borderLeftStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_borderLeftStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_borderLeftStyle;

   function Get_borderLeftStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_borderLeftStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_borderLeftStyle;

   procedure Put_width
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_width
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_width;

   function Get_width
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_width
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_width;

   procedure Put_height
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_height
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_height;

   function Get_height
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_height
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_height;

   procedure Put_styleFloat
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_styleFloat
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_styleFloat;

   function Get_styleFloat
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_styleFloat
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_styleFloat;

   procedure Put_clear
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_clear
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_clear;

   function Get_clear
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_clear
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_clear;

   procedure Put_display
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_display
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_display;

   function Get_display
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_display
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_display;

   procedure Put_visibility
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_visibility
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_visibility;

   function Get_visibility
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_visibility
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_visibility;

   procedure Put_listStyleType
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_listStyleType
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_listStyleType;

   function Get_listStyleType
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_listStyleType
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_listStyleType;

   procedure Put_listStylePosition
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_listStylePosition
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_listStylePosition;

   function Get_listStylePosition
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_listStylePosition
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_listStylePosition;

   procedure Put_listStyleImage
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_listStyleImage
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_listStyleImage;

   function Get_listStyleImage
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_listStyleImage
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_listStyleImage;

   procedure Put_listStyle
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_listStyle
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_listStyle;

   function Get_listStyle
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_listStyle
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_listStyle;

   procedure Put_whiteSpace
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_whiteSpace
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_whiteSpace;

   function Get_whiteSpace
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_whiteSpace
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_whiteSpace;

   procedure Put_top
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_top
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_top;

   function Get_top
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_top
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_top;

   procedure Put_left
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_left
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_left;

   function Get_left
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_left
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_left;

   function Get_position
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_position
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_position;

   procedure Put_zIndex
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.VARIANT;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_zIndex
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_zIndex;

   function Get_zIndex
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_zIndex
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_zIndex;

   procedure Put_overflow
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_overflow
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_overflow;

   function Get_overflow
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_overflow
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_overflow;

   procedure Put_pageBreakBefore
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_pageBreakBefore
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_pageBreakBefore;

   function Get_pageBreakBefore
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_pageBreakBefore
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_pageBreakBefore;

   procedure Put_pageBreakAfter
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_pageBreakAfter
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_pageBreakAfter;

   function Get_pageBreakAfter
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_pageBreakAfter
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_pageBreakAfter;

   procedure Put_cssText
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_cssText
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_cssText;

   function Get_cssText
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_cssText
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_cssText;

   procedure Put_cursor
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_cursor
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_cursor;

   function Get_cursor
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_cursor
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_cursor;

   procedure Put_clip
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_clip
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_clip;

   function Get_clip
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_clip
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_clip;

   procedure Put_filter
     (This : IHTMLRuleStyle_Type;
      p    : GNATCOM.Types.BSTR;
      Free : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Put_filter
         (Pointer (This),
          p));

      if Free then
               GNATCOM.IInterface.Free (p);
      
      end if;

   end Put_filter;

   function Get_filter
     (This : IHTMLRuleStyle_Type)
     return GNATCOM.Types.BSTR
   is
       RetVal : aliased GNATCOM.Types.BSTR;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.Get_filter
         (Pointer (This),
          RetVal'Unchecked_Access));

      return RetVal;
   end Get_filter;

   procedure setAttribute
     (This             : IHTMLRuleStyle_Type;
      strAttributeName : GNATCOM.Types.BSTR;
      AttributeValue   : GNATCOM.Types.VARIANT;
      lFlags           : Interfaces.C.long;
      Free             : Boolean := True)
   is
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.setAttribute
         (Pointer (This),
          strAttributeName,
          AttributeValue,
          lFlags));

      if Free then
               GNATCOM.IInterface.Free (strAttributeName);
               GNATCOM.IInterface.Free (AttributeValue);
      
      end if;

   end setAttribute;

   function getAttribute
     (This             : IHTMLRuleStyle_Type;
      strAttributeName : GNATCOM.Types.BSTR;
      lFlags           : Interfaces.C.long;
      Free             : Boolean := True)
     return GNATCOM.Types.VARIANT
   is
       RetVal : aliased GNATCOM.Types.VARIANT;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.getAttribute
         (Pointer (This),
          strAttributeName,
          lFlags,
          RetVal'Unchecked_Access));

      if Free then
               GNATCOM.IInterface.Free (strAttributeName);
      
      end if;

      return RetVal;
   end getAttribute;

   function removeAttribute
     (This             : IHTMLRuleStyle_Type;
      strAttributeName : GNATCOM.Types.BSTR;
      lFlags           : Interfaces.C.long;
      Free             : Boolean := True)
     return GNATCOM.Types.VARIANT_BOOL
   is
       RetVal : aliased GNATCOM.Types.VARIANT_BOOL;
   begin
      GNATCOM.Errors.Error_Check
        (Pointer (This).Vtbl.removeAttribute
         (Pointer (This),
          strAttributeName,
          lFlags,
          RetVal'Unchecked_Access));

      if Free then
               GNATCOM.IInterface.Free (strAttributeName);
      
      end if;

      return RetVal;
   end removeAttribute;

end MSHTML.IHTMLRuleStyle_Interface;

