Command of the Day: TAGS

[Walt Decker]

TAGS
---------
Tags are handy critters. Although tags are NOT LB "COMMANDS", LB uses them extensively. With the exception of menus, every LB event that is defined as a SUB rather than a label uses a tag as one of its arguments. SUB events that are associated with a graphic control, i. e. GRAPHICSBOX, GRAPHICS window, use a tag as its first argument.

If you are not familiar with SUB/FUNCTION usage the arguments are those parameters that follow the SUB/FUNCTION declaration:

SUB FOO Hndl, Id, Txt$
FUNCTION FOO.TOO(Hndl, Id, Txt$)

WHAT ARE THEY?
--------------
A tag is mearly a way to refer to some object. Every array and variable defined in an application is a tag, that is, a way to refer to a memory object, actually the address in memory of a large or small block of memory.

Every form and control defined in an application has a tag. For example:

CHECKBOX #DMY.CHKOPN, ......... <--- #DMY.CHKOPN is the tag
GRAPHICBOX #DMY.GFX, ........ <--- #DMY.GFX is the tag
OPEN "FOO" FOR WINDOW AS #DMY <--- #DMY is the tag

Reading/writing to a file is defined with a tag:

OPEN "FOO" FOR INPUT AS #1 <--- #1 is the tag

Loading, drawing, getting, saving, and destroying a bitmap requites a tag:

LOADBMP "MyBMP", BmpPath$ <--- MyBMP is the tag

PRINT #DMO.GFX, "drawbmp MyBMP 0 0"
PRINT #DMO.GFX, "getbmp YourBMP 0 0 200 300" <--- YourBMP is the tag

BMPSAVE "YourBMP", BmpPath$ <--- YourBMP is the tag
UNDLOADBMP "YourBMP" <--- YourBMP is the tag

The above tags contain a number. In the case of forms and controls it is the handle returned to LB by the operating system when the form or control is created. In the case of bitmaps it is the handle of a memory bitmap returned by the operating system when the bitmap is created.

SO WHAT?
--------
In LB the tag can be placed in a string variable and referred to with the string variable rather than the literal tag. For example:

Chk$ = "#DMO.CHKOPN"
#Chk$, "value? result$"

Gfx$ = "#DMO.GFX"
#Gfx$, "down"

Tag$ = "MyBMP"
LOADBMP Tag$, BmpPath$

When control events are defined as SUBs one can use the same SUB for controls of the same type and determine from the tag passed to the sub which control is activated:

'

CHECKBOX #DMO.CHKCLR, "Select Color", CHK.COLOR, CHK.COLOR, X, Y, Wide, High
CHECKBOX #DMO.CHKUSE, "Use Last", CHK.COLOR, CHK.COLOR, X, Y, Wide, High

SUB CHK.COLOR ChkHndl$

IsSet$ = ""
#ChkHndl$, "VALUE? IsSet"

SELECT CASE ChkHndl$
 CASE "#DMO.CHKCLR"
   IF IsSet$ = "set" THEN
   END IF
 CASE "#DMO.CHKUSE"
   IF IsSet$ = "set" THEN
   END IF
END SELECT
END SUB
'


The same type of thing can be done with forms and graphics. By setting up SUB/FUNCTIONS one can use one for almost any operation.

[gaslouk]

Hi Walt Decker

thanks .

[Rod]

Interesting, do we normally call that a handle or is there a difference between a handle and a tag?

[gaslouk]

Happy Holidays. Happy new year with health joy peace.

There is a difference between a handle and a tag, A tag is entered (also in other dialects of BASIC) and in a subroutine called with {GOTO}. but as a handle it cannot be used.
Gaslouk.

[Walt Decker]

There is a difference between a handle and a tag, A tag is entered (also in other dialects of BASIC) and in a subroutine called with {GOTO}. but as a handle it cannot be used.

You are confusing LABEL and TAG.

TAG always contains a number. That number always refers to some memory object, which can be in moveable memory (byte, word, dword, qword, collection), static memory (data), or device.

LABEL also contains a number; however, that number is the address of a particular place in code space and does not move. That LABEL can only be referred to by its name.  The name of a FUNCTION or SUB is also a LABEL.  In LB FUNCTION and SUB can not be referred to any other way although in more advanced systems their address can be obtained and referred to by address rather than name.

EXAMPLE:

GOTO [FOO.1]  <--- LABEL

........

........

[FOO.1]  <--- MATCHING LABEL

CALL FOO.2   <--- LABEL for a SUB

RetVal = FN.FOO.3()  <--- LABEL FOR A FUNCTION

SUB FOO.2      <--- MATCHING SUB LABEL

FUNCTION FN.FOO.3()  <--- MATCHING FUNCTION LABEL

[gaslouk]

It is the fault of the GOOGLE Translator translation.

[Walt Decker]

I see. So you entered some Greek words and the translator came up with an incorrect English translation. Understandable. But now, hopefully, you have the correct nomenclature.

Hope you have a good holiday.

[gaslouk]

Thanks The same for you.

[Rod]

I understand the tag concept but I am still confused about what a handle is. Most API tutorials show us how to get the handle of a resource. Is a handle simply a tag?

[tsh73]

The above tags contain a number. ... In the case of bitmaps it is the handle of a memory bitmap returned by the operating system when the bitmap is created.

Does it actually work as described?

'nomainwin
open "test" for graphics_nsb_nf as #gr
#gr "trapclose [quit]"
#gr "down"

#gr "home"
#gr "circle 20"
#gr "go 10"
#gr "getbmp mybmp 0 0 200 200"
print  mybmp

wait

[quit]
   close #gr
end


prints 0 as mybmp
Also then I loadbmp, it prints 0 as well.

(and I tried drawbmp - it draws OK)

[Rod]

I think hbmp() and hwnd() get the tag number back from a named Liberty resource. But in Liberty speak I have always known this as a "handle". The LBPE and even Alyce's tutorials have never mentioned "tag". So it is an interesting discussion and learning point.

[Walt Decker]

Does it actually work as described? ...
prints 0 as mybmp
Also then I loadbmp, it prints 0 as well.

Yes. The reason it prints zero is mybmp is a string, not a numeric. LB is, in part, string based. The string contains the numeric handle of the memory bitmap. So, to get a value from the tag "mybmp" you would have to use HBMP("mybmp"). PRINT MyBmp$ will print a nul string.

Remember, tags contain numbers.

DIM Foo(100) <--- Foo is the tag and contains a number, the starting address of a block of memory.

DIM Foo.too$(100) <--- Foo.too$ is the tag and points to the address of an expandable block of memory.

Tag ---> Mbmp$ = "MyBmp"
LOADBMP Mbmp$, BmpPath. LOADBMP is a function that makes an API call and creates a memory bitmap. The handle (memory address) of the bit map is placed in the tag MyBmp$.

HWND() returns the handle (number) of object defined with some tag, e. g. #1, #1.GFX, One1$

HBMP() returns the handle (number, memory address) of an object defined with some tag, e. g. "BmpGuy", "BmpGirl"

Handle is a number, not a tag.  You can call a tag a handle, if you want, but it is not quite correct.

[tsh73]

Yes, me too always seen "number connected to Windows resource" as "handle".
But I pretty sure I know very little of this stuff.

just googled
stackoverflow.com/questions/902967/what-is-a-windows-handle
There is a rabbit hole down there, will read along the links... not expect me back soon

[Walt Decker]

Dec 29, 2022 3:11:23 GMT -5 Rod said:

I understand the tag concept but I am still confused about what a handle is. Most API tutorials show us how to get the handle of a resource. Is a handle simply a tag?

No.  Handle is a number

EDIT:

I GOOFED. Yes, "handle" is just a tag that contains a number.

Think of it this way:

Walt Decker is a tag that points to a lump of protoplasm on some rock circling a star somewhere in a galaxy somewhere in a universe that might be one of a group of universes. It is not the lump nor does it describe the lump. The tag only points to the lump.

CtlId = 0  '<--- Tag (name)

WinHndl = HWND(#MYWIN,CHKBX1) '<--- WinHndl tag (Name) #MYWIN.CHKBX1 is a tag that contains the handle (numeric identifier) of the control

CALLDLL #user32, "GetDlgCtrlID", WinHndl AS ULONG, CtlId AS LONG

The handle (number) of the control is in  tag (name) WinHndl

The Id (number) of the control is in tag (name) Ctlid

In most languages handles (numbers) are placed in numeric variables tags.  LB places them in string tags.  That is why you can refer to a handle as #MY.CKBX or as #MYCKBX$ provide the tag is placed in string MYCKBX$.  LB automatically makes the conversion to a number in either case.