What?

Why?

cpp code:

---

typedef struct tagPOINT {
  LONG x;
  LONG y;
} POINT, *PPOINT;

---

js code:

---

var pt = Interop.Allocate(8);
Interop.Call( 'user32', 'GetCursorPos', pt );
var x = pt.ReadDWORD(0);
var y = pt.ReadDWORD(4);

---

js code:

---

var POINT = new StructType({
    x: DataType.LONG,
    y: DataType.LONG
};
var pt = new POINT;
Interop.Call( 'user32', 'GetCursorPos', pt.dataptr() );
var x = pt.x();
var y = pt.y();

---

js code:

---

var LVITEM = new StructType({
    mask:            DataType.UINT,
    iItem:            DataType.INT,
    iSubItem:        DataType.INT,
    state:            DataType.UINT,
    stateMask:        DataType.UINT,
    pszText:        DataType.LPTSTR,
    cchTextMax:        DataType.INT,
    iImage:            DataType.INT,
    lParam:            DataType.LONG,
    iIndent:        DataType.INT,
    iGroupId:        DataType.INT,
    cColumns:        DataType.UINT,
    puColumns:        DataType.UINT
});

var firstItem = new LVITEM;
firstItem.mask( /* LVIF_TEXT */ 0x1 );
firstItem.pszText( 'First item' );

PlusWnd.SendControlMessage( 'MyListView', /* LVM_INSERTITEMW */ (0x1000 + 77), 0, firstItem.dataptr() );

---

Features

• Define once, use forever. By defining a structure type, you create a new class which creates structures. You can create as many class instances as you want, so you don't have to redefine that type ever again.
  
• Defining structures is almost like copy pasting from MSDN. You can use the same names for the members and in almost all cases, you can use the same names for the data types as well. If MSDN says that 'mask' is a LONG, then just define it as a DataType.LONG, no need to figure out the corresponding DataBloc method any more.
  
• Accessing members couldn't be easier: just use their names. No more fiddling with memory positions, the class always knows where the members are located.
  
• Combined getter/setter methods for each member. To write a value to a member, pass it as the first parameter. To read the value of a member, just pass no arguments. Can it be any easier?
  

  js code:

  ---

  // Get
  var x = struct.myMember();
  // Set
  struct.myMember(10);

  ---

• Convert values automatically to the right type. Some DataTypes have a custom setter methods which allow you to pass a value in different types, such a string for an LPSZ, an [x,y] array for a POINT or red/green/blue values for a COLORREF.
  
• Use structures in structures. Occasionally, you'll find that a structure contains another structure. For example, NMLISTVIEW has a NMHDR structure for its 'hdr' member. Instead of copying the members of NMHDR to NMLISTVIEW, just create an NMHDR type and use it within NMLISTVIEW:
  

  js code:

  ---

  var NMHDR = new StructType({
      hwndFrom:    DataType.HWND,
      idFrom:        DataType.UINT,
      code:        DataType.UINT
  });
  var NMLISTVIEW = new StructType({
      hdr:        NMHDR,
      iItem:        DataType.INT,
      iSubItem:    DataType.INT,
      uNewState:    DataType.UINT,
      uOldState:    DataType.UINT,
      uChanged:    DataType.UINT,
      ptAction:    DataType.POINT,
      lParam:        DataType.LONG
  });

  ---

  You can then access a sub structure member with:
  

  js code:

  ---

  var nmListView = new NMLISTVIEW;
  var hwndFrom = nmListView.hdr().hwndFrom();

  ---

  This is possible since StructTypes double as DataTypes, so you can use them just like you'd use a DataType. (prototypical inheritance ftw!)
  
• Easily work with datatype arrays. Some structures take an array of values for a single member, for example LOGFONT takes an array of 32 TCHARS for its 'lfFaceName' member. Instead of defining 32 different TCHAR members in a structure type, you can use DataType.Array to create an array-like data type with a fixed length.
  

  js code:

  ---

  var LF_FACESIZE = 32;
  var LOGFONT = new StructType({
      lfHeight:    DataType.LONG,
      // ...
      lfFaceName:    DataType.Array(DataType.TCHAR, LF_FACESIZE)
  });
  var font = new LOGFONT;
  // Write a single item to a specific index
  font.lfFaceName().item(0, 'a');
  // Read a single item from a specific index
  var char = font.lfFaceName().item(0);
  // Write an array
  font.lfFaceName().fromArray(['a', 'b', 'c']);
  // Read as an array
  var chars = font.lfFaceName().toArray();
  // (W)CHAR arrays even have extra methods for easier handling
  font.lfFaceName().fromString('abcdef');
  var fontFace = font.lfFaceName().toString();

  ---

Download

Change-log

• 1.0.001 (7 November 2010)
  
  • Initial release.

To-do

• More DataTypes? Post your suggestions below!

quote:

---

Originally posted by Matti
I spend some time today trying to get this to work, and eventually I got it working.

---

At the moment, I implemented some basic types (BOOL, WORD, INT, CHAR, LPWSTR) and some common synonyms (UINT, DWORD, LONG). I also added a POINT type which basically writes an array [x, y] to two INTs.

To define a DataType, you just need to specify its size in bytes and a getter and setter method. For example, INT is defined with size 4 and two methods which simply map to ReadDWORD and WriteDWORD. For LPWSTR, the getter method uses some functions from kernel32 to get the string length of the pointer, then copy its contents and read it. The setter simply creates a DataBloc storing the given string and writes the pointer to that block.

This can still be extended upon though, I'm thinking about adding the possibility to use other StructTypes as DataTypes. For example, a NMLISTVIEW structure has an NMHEADER structure for its first 16 bytes. Instead of redefining the NMHEADER members in the NMLISTVIEW definition, it can be easier to just use NMHEADER as the data type of the first member hdr.

Ultimately, you should be able to just copy-paste the structure definitons from MSDN and rewrite it to produce a valid JavaScript hash with keys and data types. I'm not there yet, but even in this early stage it made my life much easier while working on the new ListView class!

You should add this by default

http://msdn.microsoft.com/en-us/library/aa383751(VS.85).aspx

Wow, looks like I've missed something in the past 36 hours

@Matti: it might come in handy to have something like StructureType.AddDataType(); that accepts a type name, a size and how to write it into the DataBloc obect (ie: using writeDWORD(); or writeSTRING(), or to send a callback function along with it that receives the position and data to write.

quote:

---

Originally posted by matty
You should add this by default

http://msdn.microsoft.com/en-us/library/aa383751(VS.85).aspx

---

quote:

---

Originally posted by SmokingCookie
Wow, looks like I've missed something in the past 36 hours

@Matti: it might come in handy to have something like StructureType.AddDataType(); that accepts a type name, a size and how to write it into the DataBloc obect (ie: using writeDWORD(); or writeSTRING(), or to send a callback function along with it that receives the position and data to write.

---

js code:

---

DataType.INT = new DataType({
    size : 4,
    read : function( databloc, position ) {
        return databloc.ReadDWORD( position );
    },
    write : function ( databloc, position, value ) {
        databloc.WriteDWORD( position, (1*value) & 0xFFFFFFFF );
    }
});

---

It's quite funny how similar your struct system is to one I started making

How do you define elements that are arrays with your system? e.g. lfFaceName in LOGFONT.
I was trying to find a clean way of doing it, but I gave up (unlike me! )

Here's an example for what I did for strings:

js code:

---

API.typedef('string', function(length){
    return {
        size : ((length + 1) * 2),
        get  : function(dataBloc, offset) {
            return dataBloc.ReadString(offset);
        },
        set  : function(dataBloc, offset, value) {
            dataBloc.WriteString(offset, value);
        }
    }
});

---

quote:

---

Originally posted by Eljay
But I "built" the DataBloc during construction rather than with an extra function, so it might be easier to do variable-size members your way.

---

js code:

---

var LOGFONT = new StructType({
    // ...
    lfFaceName: new DataType.TCHAR(32)
});

---

The signed/unsigned behaviour and handling was the first thing I was wondering about when I saw you made a class for this, Matti. I was wondering if you took that into account... (since the WriteDWORD function can accept signed values too, yet you make it possible to define stuff like UINT, etc)... but I didn't checked your code yet to see for myself if you took that into account (lazy )... Anyways, since you brought it up...

quote:

---

Originally posted by Matti
While I was playing with these signed/unsigned types, I saw that the code member from NMHDR was defined as a UINT, but could also take signed values (e.g. LVN_COLUMNCLICK = -108) so to get around this, I defined code as an INT instead. Anyone has a valid explanation for this behavior? Source: NMHDR on MSDN

---

I hope I make some sense here, it's already late and I didn't slept much last nights either...

Thanks for the very thorough explanation, Cookie! I already had such conversions implemented in my getters, I just needed to do the signed to unsigned conversion on LVN_COLUMNCLICK as well to make my comparison work. For ease of use, I exposed these methods in Number.toUnsigned(), Number.toSigned() and Number.toUINT(). Then again, it's a bit counter-intuitive to have DataBloc.ReadWORD() and ReadDWORD() take signed numbers while WORD and DWORD are both unsigned...

Since this thread is now separated from the list-view groups topic, I updated the first post with some details about the class. This should give you a better idea on what's coming.

It's here! The first version of the class is now available. Go get it from the download link in the first post.
All suggestions are implemented, such as proper handling of signed/unsigned numbers and data type arrays (e.g. TCHAR[32]).

To get started, have a look at the usage examples in the first post. If you're looking for a list of all built-in data types, check out the source code and you'll find them below "Data Type Definitions", "Aliases" and "Common structure types" near the bottom of the file. It's a pretty long list, so I'm not going to post it here, but rest assured that most of the types you'll use are included.

With this version, you should be able to define almost any structure type you want. If you still find a certain member type which cannot be properly defined with this class, post about it here and I'll see if it can be improved. In case you find that the class is not functioning correctly, don't hesitate to report it here!