Let it not be said that Microsoft can’t screw up royally. In my opinion, this was a major bug.

In short, this bug causes any 32-bit applications running on a 64-bit OS that queries the OS for the current Registered Owner and Registered Company Name to be returned invalid data. A 64-bit application would get the correct values.

I am unsure whether this affects just queries made to the registry itself (which I personally verified as incorrect) or whether the API calls to return the same information return those same invalid values.

In either case, if your a developer using this information to form a licensing hash for tying a software license to a machine expect people to start showing up unregistered, which is exactly what happened to us.

1. Uses statement changes

First and foremost, all the unit names have changed. In previous versions all you needed to include in your uses statements were 3 PAS files, Ltdlldef, Ltdlltyp and Ltdllunt. This is no longer the case, all the functions have been broken up into individual units. In my application alone this went up to 12 files (Ltlck, LTDLLUnt, Lterr, Lttyp, Ltfil, Ltfil_f, Ltkrn, Lvkrn, Lvkrn_f, Ltkrn_f, Ltimgclr_f, Ltdis_f). If you count the actual .PAS files in the Uses sub-folder of your LeadTools installation you will see it went from 4 up to 102, so substantial changes were made in the structure of the package. Not saying they weren’t needed, but some documentation would have been nice.

Thankfully Delphi still comes with ol’ faithful GREP, so this will be helpful in finding the files you need to include.

2. VECTORPOLYLINE and VECTORPOLYGON have gone missing

For those enumerating through a vector files objects, you may have seen these types come up a time or two. They correspond to the Object type constants VECTOR_POLYLINE and VECTOR_POLYGON. These two structures have been renamed to VECTORCURVEOPENED (the old VECTORPOLYLINE) and VECTORCURVEOPENED (the old VECTORPOLYGON). The type constants have remained the same names however, which added to some confusion on my part initially.

3. VECTORxxx structure _Object field renamed to uObject

Also for those who enumerated through objects, you were used to the _Object variable contained within each vector structure that corresponded to the basic entity data. This field has been renamed to a less clunky uObject.

4. VECTORPEN changes

The VECTORPEN structure used to have a Pen field that was a EXTLOGPEN type. This has been renamed to uPenUnion and is now a union structure containing both a LOGPEN and EXTLOGPEN. Basically, when your old call to the color of the Pen would have been VECTORLINE.Pen.Pen.elpColor for instance, it is now VECTORLINE.Pen.uPenUnion.uExtLogPen.elpColor.

5. Vector Library unlock code

Although I was given a brand new v17 unlock code string to pass to L_UnlockSupport, I received -400 (ERROR_VECTOR_NOT_ENABLED) when making any vector calls. I had to use my 16.5 unlock code string to enable vector functionality on my development machine. I also have both 16.5 and 17 versions of LeadTools installed on this machine. However when the new exe was distributed, it did not work on that machine, I had to put back the v17 unlock code string, making it no longer work on my machine. I’m most likely going to have to rename the directory the v16.5 DLLs are in to make it work on my machine simultaneously as the clients machine.

I hope this list helps some of you get up and running as quickly as possible in v17!

I have not fully been able to track down the cause for this, whether it is the system variable DRAWORDERCTL or object variable DRAWORDER. I also did not see in AutoCAD LT a way to reset an objects DRAWORDER, if that can even be done.

Personally I don’t care about the draw order as we bring across the objects into our own format and we don’t draw things in an enforced order anyway, we have a particular way in which we handle draw order.

However when using LeadTools’ L_VecPaint() to draw, the draw order is important. Apparently, AutoCAD draw everything in a particular object order, irregardless of layer, with the only way to change this order is the use of BringToFront, SendToBack, etc. LeadTools however draws in layer order, drawing all the objects on a particular layer before moving onto the next layer.

This causes an issue when trying to faithfully reproduce a sketch as it would have been drawn in AutoCAD, as it might not draw the objects in proper order. To “fix” this, they, instead of keeping the layer property’s as they are in the file, they modify them and force all objects onto the ’0′ layer, this way object order is preserved, if not the data.

To me the data would be more important, however I guess it’s just me.

LeadTools doesn’t currently support drawing in monochrome or grayscale, so I had to write code to do it myself.

I do this by copying the VECTORHANDLE to another one (L_VecCopy), then converting that one to grayscale. I only have need for groups, polylines, polygons, lines, arcs, circles and text in my drawings, but the other supported types can be added easily enough.

Pass your VECTORHANDLE to the function GrayScaleVectorFile() and you are done. You will need to modify it if you intend to pass a custom pUserData.

function GrayScaleColor (InColor : Integer) : Integer;
// a color to greyscale algorithm I found online
var
  GrayShade, Red, Green, Blue : Byte;
  PixelColor : Integer;
begin
  PixelColor := ColorToRGB (InColor);
  Red        := PixelColor;
  Green      := PixelColor shr 8;
  Blue       := PixelColor shr 16;
  Grayshade  := Round(0.3 * Red + 0.6 * Green + 0.1 * Blue);
  Result     := RGB(Grayshade, Grayshade, Grayshade);
end; { GrayScaleColor }

function ProcessVectorGrayScale (pVector : pVECTORHANDLE; pObject : pVECTOROBJECT; pUserData : Pointer) : Integer; far; stdcall;
var
  vp : VECTORPOLYLINE;
  Vo : VECTORPOLYGON;
  Vl : VECTORLINE;
  Va : VECTORARC;
  Vc : VECTORCIRCLE;
  Vt : VECTORTEXT;
  Vclone : VECTORCLONE;
begin
  with PAxSketchData(pUserData)^.CurFile, CurPage do begin
    case pObject.nType of
      VECTOR_CLONE : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Vclone);
        Vclone.Pen.Pen.elpColor := GrayScaleColor (Vclone.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Vclone);
        end; { VECTOR_CLONE }
      VECTOR_POLYLINE : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Vp);
        Vp.Pen.Pen.elpColor := GrayScaleColor (Vp.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Vp);
        end; { VECTOR_POLYLINE }
      VECTOR_POLYGON : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Vo);
        Vo.Pen.Pen.elpColor := GrayScaleColor (Vo.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Vo);
        end; { VECTOR_POLYGON }
      VECTOR_LINE : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Vl);
        Vl.Pen.Pen.elpColor := GrayScaleColor (Vl.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Vl);
        end; { VECTOR_LINE }
      VECTOR_ARC : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Va);
        Va.Pen.Pen.elpColor := GrayScaleColor (Va.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Va);
        end; { VECTOR_ARC }
      VECTOR_CIRCLE : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Vc);
        Vc.Pen.Pen.elpColor := GrayScaleColor (Vc.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Vc);
        end; { VECTOR_CIRCLE }
      VECTOR_TEXT : begin
        L_VecGetObject (pVector, pObject, pObject.nType, @Vt);
        Vt.Pen.Pen.elpColor := GrayScaleColor (Vt.Pen.Pen.elpColor);
        L_VecSetObject (pVector, pObject, pObject.nType, @Vt);
        end;{ VECTOR_TEXT }
    end; { case }
    end; { with }

  Result := SUCCESS;
end; { ProcessVectorGrayScale }

function ProcessVectorObjectsInGroupGrayScale (pVector : pVECTORHANDLE; pObject : pVECTOROBJECT; pUserData : Pointer) : Integer; far; stdcall;
begin
  Result := ProcessVectorGrayScale (pVector, pObject, pUserData);
end; { ProcessVectorObjectsInGroupGrayScale }

function ProcessVectorGroupsGrayScale (pVector : pVECTORHANDLE; pGroup : pVECTORGROUP; pUserData : Pointer) : Integer; far; stdcall;
var
  Grp : VECTORGROUPDESC;
begin
  FillChar (Grp, SizeOf(VECTORGROUPDESC), #0);
  if L_VecGetGroup (pVector, pGroup, @Grp) = SUCCESS then
    L_VecEnumObjectsInGroup (pVector, pGroup, @ProcessVectorObjectsInGroupGrayScale, nil, 0);

  Result := SUCCESS;
end; { ProcessVectorGroupsGrayScale }

procedure GrayScaleVectorFile (pVector : pVECTORHANDLE);
begin
  L_VecEnumObjects (pVector, @ProcessVectorGrayScale, nil, 0);
  L_VecEnumGroups (pVector, @ProcessVectorGroupsGrayScale, nil);
end; { GrayScaleVectorFile }