«

Microsoft-

I have a few COM interfaces which use the OLE_HANDLE type to pass HWNDs or
HBITMAPs. Several Microsoft defined interfaces also use OLE_HANDLE (e.g.
IPicture::get_Handle), but in VS.NET 2005, OLE_HANDLE is still 32 bits!

Wondering about this, I created a simple experiment where I create very
large numbers of windows or bitmaps. In both cases, I never received a
handle which could not be represented in 32 bits (never exceeded 0xFFFFFFFF).
Is this a guarantee on x64? If not, how can Microsoft’s picture object
continue to work? Is all the hoopla about using (for example)
SetWindowLongPtr really just for IA developers? Please clarify.

Thanks,

R.

Great place to post this question:
microsoft.public.vsnet.general

--
Andre
Extended64 | http://www.extended64.com
Blog | http://www.extended64.com/blogs/andre
http://spaces.msn.com/members/adacosta
FAQ for MS AntiSpy http://www.geocities.com/marfer_mvp/FAQ_MSantispy.htm
"COM Developer" <COM > wrote in message
news:B2D99CF3-CB2F-4DFA-BC08-...
> Microsoft-
>
> I have a few COM interfaces which use the OLE_HANDLE type to pass HWNDs or
> HBITMAPs. Several Microsoft defined interfaces also use OLE_HANDLE (e.g.
> IPicture::get_Handle), but in VS.NET 2005, OLE_HANDLE is still 32 bits!
>
> Wondering about this, I created a simple experiment where I create very
> large numbers of windows or bitmaps. In both cases, I never received a
> handle which could not be represented in 32 bits (never exceeded
> 0xFFFFFFFF).
> Is this a guarantee on x64? If not, how can Microsoft’s picture object
> continue to work? Is all the hoopla about using (for example)
> SetWindowLongPtr really just for IA developers? Please clarify.
>
> Thanks,
>
> R.
>

SetWindowLongPtr is of course irrelevant (and still needed). Still need the
rest of the question answered.


"COM Developer" wrote:

> Microsoft-
>
> I have a few COM interfaces which use the OLE_HANDLE type to pass HWNDs or
> HBITMAPs. Several Microsoft defined interfaces also use OLE_HANDLE (e.g.
> IPicture::get_Handle), but in VS.NET 2005, OLE_HANDLE is still 32 bits!
>
> Wondering about this, I created a simple experiment where I create very
> large numbers of windows or bitmaps. In both cases, I never received a
> handle which could not be represented in 32 bits (never exceeded 0xFFFFFFFF).
> Is this a guarantee on x64? If not, how can Microsoft’s picture object
> continue to work? Is all the hoopla about using (for example)
> SetWindowLongPtr really just for IA developers? Please clarify.
>
> Thanks,
>
> R.
>

Will do, Thanks.

"Andre Da Costa" wrote:

> Great place to post this question:
> microsoft.public.vsnet.general
>
> --
> Andre
> Extended64 | http://www.extended64.com
> Blog | http://www.extended64.com/blogs/andre
> http://spaces.msn.com/members/adacosta
> FAQ for MS AntiSpy http://www.geocities.com/marfer_mvp/FAQ_MSantispy.htm
> "COM Developer" <COM > wrote in message
> news:B2D99CF3-CB2F-4DFA-BC08-...
> > Microsoft-
> >
> > I have a few COM interfaces which use the OLE_HANDLE type to pass HWNDs or
> > HBITMAPs. Several Microsoft defined interfaces also use OLE_HANDLE (e.g.
> > IPicture::get_Handle), but in VS.NET 2005, OLE_HANDLE is still 32 bits!
> >
> > Wondering about this, I created a simple experiment where I create very
> > large numbers of windows or bitmaps. In both cases, I never received a
> > handle which could not be represented in 32 bits (never exceeded
> > 0xFFFFFFFF).
> > Is this a guarantee on x64? If not, how can Microsoft’s picture object
> > continue to work? Is all the hoopla about using (for example)
> > SetWindowLongPtr really just for IA developers? Please clarify.
> >
> > Thanks,
> >
> > R.
> >
>
>

I think that perhaps your experiment asks the wrong questions. As I
understand it, the API requires you to provide room for 64bit wide
arguments, and stuff - that is no guarantee that anything has to actually
scale to that size, if you go asking for credentials, it could be anything,
and it could be a long time before you see a 64bit number from a Handle.

The number of Handles has to be limited in reality, but you are in an 64bit
environment and handles are used in all sorts of situations, so to ! risk
breaking compatibility, you are required to dance to the tune???

It's been a long time since I did any of that stuff, but I think I can
remember sort of the same discussion arising when we went 32bit. Feel free
to scorn me, should I be wrong.

Tony. . .


"COM Developer" <> wrote in message
news:16B1ECEB-8F53-45DE-BB44-...
> SetWindowLongPtr is of course irrelevant (and still needed). Still need
> the
> rest of the question answered.
>
>
> "COM Developer" wrote:
>
>> Microsoft-
>>
>> I have a few COM interfaces which use the OLE_HANDLE type to pass HWNDs
>> or
>> HBITMAPs. Several Microsoft defined interfaces also use OLE_HANDLE (e.g.
>> IPicture::get_Handle), but in VS.NET 2005, OLE_HANDLE is still 32 bits!
>>
>> Wondering about this, I created a simple experiment where I create very
>> large numbers of windows or bitmaps. In both cases, I never received a
>> handle which could not be represented in 32 bits (never exceeded
>> 0xFFFFFFFF).
>> Is this a guarantee on x64? If not, how can Microsoft's picture object
>> continue to work? Is all the hoopla about using (for example)
>> SetWindowLongPtr really just for IA developers? Please clarify.
>>
>> Thanks,
>>
>> R.
>>