teblndwk.pas

Do your applications look a little boring? Would you like to get spectacular yet easy to use visual

          CopyMemory(Data, @BodyColorNoCmp1, SizeOf(BodyColorNoCmp1));
          Result := SizeOf(BodyColorNoCmp1);
        end;
        PDWord(@Data[1])^ := Color;
      end
    end
    else
    begin
      if DoComp
      then
      begin
        CopyMemory(Data, @BodyMemCmp, SizeOf(BodyMemCmp));
        Result := SizeOf(BodyMemCmp);
      end
      else
      begin
        CopyMemory(Data, @BodyMemNoCmp, SizeOf(BodyMemNoCmp));
        Result := SizeOf(BodyMemNoCmp);
      end;
    end;
  end;

  function MultX(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..18] of Byte = (
      $69,$C9,$80,$00,$00,$00, 
      $69,$DB,$80,$00,$00,$00, 
      $C1,$E9,$08,             
      $C1,$EB,$08);            
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[ 2])^ := Factor;
    PByte(@Data[ 8])^ := Factor;
    PByte(@Data[14])^ := Shift;
    PByte(@Data[17])^ := Shift;
    Result := SizeOf(Code);
  end;

  function Mult0(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..6] of Byte = (
      $C1,$E9,$08,  
      $C1,$EB,$08); 
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[2])^ := Shift;
    PByte(@Data[5])^ := Shift;
    Result := SizeOf(Code);
  end;

  function Mult1(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..12] of Byte = (
      $8D,$0C,$49, 
      $8D,$1C,$5B, 
      $C1,$E9,$08, 
      $C1,$EB,$08);
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[ 8])^ := Shift;
    PByte(@Data[11])^ := Shift;

    case Factor of
      5: begin
           PByte(@Data[2])^ := $89;
           PByte(@Data[5])^ := $9B;
         end;
      9: begin
           PByte(@Data[2])^ := $C9;
           PByte(@Data[5])^ := $DB;
         end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult2(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..18] of Byte = (
      $8D,$0C,$89, 
      $8D,$1C,$9B, 
      $8D,$0C,$C9, 
      $8D,$1C,$DB, 
      $C1,$E9,$08, 
      $C1,$EB,$08);
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[14])^ := Shift;
    PByte(@Data[17])^ := Shift;

    case Factor of
      15: begin
            PByte(@Data[ 8])^ := $49;
            PByte(@Data[11])^ := $5B;
          end;
      25: begin
            PByte(@Data[ 8])^ := $89;
            PByte(@Data[11])^ := $9B;
          end;
      27: begin
            PByte(@Data[ 2])^ := $49;
            PByte(@Data[ 5])^ := $5B;
          end;
      81: begin
            PByte(@Data[ 2])^ := $C9;
            PByte(@Data[ 5])^ := $DB;
          end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult3(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..22] of Byte = (
      $50,         
      $56,         
      $8D,$04,$89, 
      $8D,$34,$9B, 
      $8D,$0C,$C1, 
      $8D,$1C,$F3, 
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[16])^ := Shift;
    PByte(@Data[20])^ := Shift;

    case Factor of
      19: begin
            PByte(@Data[ 4])^ := $C9;
            PByte(@Data[ 7])^ := $DB;
            PByte(@Data[10])^ := $41;
            PByte(@Data[13])^ := $73;
          end;
      21: begin
            PByte(@Data[10])^ := $81;
            PByte(@Data[13])^ := $B3;
          end;
      37: begin
            PByte(@Data[ 4])^ := $C9;
            PByte(@Data[ 7])^ := $DB;
            PByte(@Data[10])^ := $81;
            PByte(@Data[13])^ := $B3;
          end;
      73: begin
            PByte(@Data[ 4])^ := $C9;
            PByte(@Data[ 7])^ := $DB;
          end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult4(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..24] of Byte = (
      $50,         
      $56,         
      $8D,$04,$89, 
      $8D,$34,$9B, 
      $01,$C9,     
      $01,$DB,     
      $01,$C1,     
      $01,$F3,     
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[18])^ := Shift;
    PByte(@Data[22])^ := Shift;

    case Factor of
      11: begin
            PByte(@Data[4])^ := $C9;
            PByte(@Data[7])^ := $DB;
          end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult5(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..34] of Byte = (
      $50,                             
      $56,                             
      $8D,$04,$89,                     
      $8D,$34,$9B,                     
      $8D,$0C,$CD, $00, $00, $00, $00, 
      $8D,$1C,$DD, $00, $00, $00, $00, 
      $01,$C1,                         
      $01,$F3,                         
      $C1,$E9,$08,                     
      $5E,                             
      $C1,$EB,$08,                     
      $58);                            
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[28])^ := Shift;
    PByte(@Data[32])^ := Shift;

    case Factor of
      17: begin
            PByte(@Data[4])^ := $C9;
            PByte(@Data[7])^ := $DB;
          end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult6(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..28] of Byte = (
      $50,         
      $56,         
      $8D,$04,$49, 
      $8D,$34,$5B, 
      $8D,$0C,$C9, 
      $8D,$1C,$DB, 
      $8D,$0C,$C8, 
      $8D,$1C,$DE, 
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[22])^ := Shift;
    PByte(@Data[26])^ := Shift;

    case Factor of
      39: begin
            PByte(@Data[16])^ := $88;
            PByte(@Data[19])^ := $9E;
          end;
      43: begin
            PByte(@Data[10])^ := $89;
            PByte(@Data[13])^ := $9B;
          end;
      77: begin
            PByte(@Data[ 4])^ := $89;
            PByte(@Data[ 7])^ := $9B;
          end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult7(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..26] of Byte = (
      $50,         
      $56,         
      $8D,$04,$49, 
      $8D,$34,$5B, 
      $C1,$E1,$06, 
      $C1,$E3,$06, 
      $29,$C1,     
      $29,$F3,     
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[20])^ := Shift;
    PByte(@Data[24])^ := Shift;

    case Factor of
       23: begin
             PByte(@Data[ 4])^ := $C9;
             PByte(@Data[ 7])^ := $DB;
             PByte(@Data[10])^ := $05;
             PByte(@Data[13])^ := $05;
           end;
       29: begin
             PByte(@Data[10])^ := $05;
             PByte(@Data[13])^ := $05;
           end;
       35: begin
             PByte(@Data[10])^ := $05;
             PByte(@Data[13])^ := $05;
             PByte(@Data[14])^ := $01;
             PByte(@Data[16])^ := $01;
           end;
       49: begin
             PByte(@Data[ 9])^ := $E0;
             PByte(@Data[12])^ := $E6;
             PByte(@Data[10])^ := $04;
             PByte(@Data[13])^ := $04;
             PByte(@Data[14])^ := $01;
             PByte(@Data[16])^ := $01;
           end;
       55: begin
             PByte(@Data[ 4])^ := $C9;
             PByte(@Data[ 7])^ := $DB;
           end;
       59: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
           end;
       67: begin
             PByte(@Data[14])^ := $01;
             PByte(@Data[16])^ := $01;
           end;
       69: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
             PByte(@Data[14])^ := $01;
             PByte(@Data[16])^ := $01;
           end;
       97: begin
             PByte(@Data[ 9])^ := $E0;
             PByte(@Data[12])^ := $E6;
             PByte(@Data[10])^ := $05;
             PByte(@Data[13])^ := $05;
             PByte(@Data[14])^ := $01;
             PByte(@Data[16])^ := $01;
           end;
      119: begin
             PByte(@Data[ 4])^ := $C9;
             PByte(@Data[ 7])^ := $DB;
             PByte(@Data[10])^ := $07;
             PByte(@Data[13])^ := $07;
           end;
      123: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
             PByte(@Data[10])^ := $07;
             PByte(@Data[13])^ := $07;
           end;
      125: begin
             PByte(@Data[10])^ := $07;
             PByte(@Data[13])^ := $07;
           end;
    end;

    Result := SizeOf(Code);
  end;

  function Mult8(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..24] of Byte = (
      $50,         
      $56,         
      $89,$C8,     
      $89,$DE,     
      $C1,$E1,$05, 
      $C1,$E3,$05, 
      $29,$C1,     
      $29,$F3,     
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[18])^ := Shift;
    PByte(@Data[22])^ := Shift;

    case Factor of
       33: begin
             PByte(@Data[12])^ := $01;
             PByte(@Data[14])^ := $01;
           end;
       63: begin
             PByte(@Data[ 8])^ := $06;
             PByte(@Data[11])^ := $06;
           end;
       65: begin
             PByte(@Data[ 8])^ := $06;
             PByte(@Data[11])^ := $06;
             PByte(@Data[12])^ := $01;
             PByte(@Data[14])^ := $01;
           end;
      127: begin
             PByte(@Data[ 8])^ := $07;
             PByte(@Data[11])^ := $07;
           end;
    end;
    Result := SizeOf(Code);
  end;

  function Mult9(Data: PByteArray; Factor, Shift: Byte): Integer;  //EROC itnA
  const
    Code: array[1..30] of Byte = (
      $50,         
      $56,         
      $89,$C8,     
      $89,$DE,     
      $8D,$0C,$49, 
      $8D,$1C,$5B, 
      $C1,$E1,$04, 
      $C1,$E3,$04, 
      $29,$C1,     
      $29,$F3,     
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[24])^ := Shift;
    PByte(@Data[28])^ := Shift;

    case Factor of
      71: begin
            PByte(@Data[ 8])^ := $C9;
            PByte(@Data[11])^ := $DB;
            PByte(@Data[14])^ := $03;
            PByte(@Data[17])^ := $03;
          end;
      79: begin
            PByte(@Data[ 8])^ := $89;
            PByte(@Data[11])^ := $9B;
          end;
      95: begin
            PByte(@Data[14])^ := $05;
            PByte(@Data[17])^ := $05;
          end;
    end;
    Result := SizeOf(Code);
  end;

  function Mult10(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..32] of Byte = (
      $50,         
      $56,         
      $8D,$04,$49, 
      $8D,$34,$5B,