Sancho: Created page with "
{{DISPLAYTITLE:Other Instructions}}
{{BreadCrumbL10n}} {{Documentation/BASICGuideTOC |Sh..."

2011-09-01T15:48:27Z

Created page with "<section begin=title /><noinclude>{{DISPLAYTITLE:</noinclude>Other Instructions<noinclude>}}</noinclude><section end=title />{{BreadCrumbL10n}} {{Documentation/BASICGuideTOC |Sh..."

New page

<section begin=title /><noinclude>{{DISPLAYTITLE:</noinclude>Other Instructions<noinclude>}}</noinclude><section end=title />{{BreadCrumbL10n}}

{{Documentation/BASICGuideTOC
|ShowPrevNext=block
|ShowPrevPage=block
|PrevPage=EN/documentation/basic_guide/error_handling
|NextPage=EN/documentation/basic_guide/runtime_library
|lang=block
}}

__NOTOC__

== '''<tt>Type...End Type</tt>''' ==

A ''struct'' is a collection of data fields, that can be manipulated as a single item. In older terms, you may think of a struct as a record, or part of a record.

The [[EN/documentation/basic_guide/api_intro|API]] often uses pre-defined structs, but these are ''UNO structs'', a highly-specialized kind of struct.

=== Definition ===

With the <tt>Type...End Type</tt> statements, you can define your own (non-UNO) structs:

<source lang="oobas">
Type aMenuItem 'assign the name of the type
'Define the data fields within the struct. Each
' definition looks like a Dim statement, without the "Dim".
aCommand as String
aText as String
End Type 'close the definition
</source>

=== Instance ===

The <tt>Type</tt> definition is only a pattern or template, not a set of actual variables. To make an ''instance'' of the type, actual variables that can be read and stored, use the <tt>Dim as New</tt> statement:

<source lang="oobas">
Dim maItem as New aMenuItem
</source>

=== Scope ===

As shown in the example below, the <tt>Type</tt> definition may be written at the start of a module (before the first <tt>Sub</tt> or <tt>Function</tt>). The definition will then be available to all routines in the module.

As of {{OOo}} Version 3.0, unlike variables, there is no way to make the definition accessible outside of the module.

An instance of the new type ''is'' a variable, and follows the usual rules for variable scope (see [[EN/documentation/basic_guide/scope_of_variables|Scope and Life Span of Variables]]).

An example of how to use the definition, and how to reference the fields within an instance, appears in the section on <tt>With...End With</tt>.

== '''<tt>With...End With</tt>''' ==
=== Qualifiers ===
In general, Basic does not look inside a container, such as an <tt>Object</tt>, to see what names might be defined there. If you want to use such a name, you must tell Basic where to look. You do that by using the name of the object as a ''qualifier''. Write it before the inner name, and separate it by a period:

MyObject.SomeName

Since containers may hold other containers, you may need more than one qualifier. Write the qualifiers in order, from outer to inner:

OuterObject.InnerObject.FarInsideObject.SomeName

These names may also be described as, "concatenated with the dot-operator ('.')".

=== The <tt>With</tt> Alternative ===

The <tt>With...End With</tt> bracketing statements provide an alternative to writing out all the qualifiers, every time - and some of the qualifiers in the API can be quite long. You specify the qualifiers in the <tt>With</tt> statement. Until Basic encounters the <tt>End With</tt> statement, it looks for ''partly-qualified'' names: names that begin with a period (unary dot-operator). The compiler uses the qualifiers from the <tt>With</tt> as though they were written in front of the partly-qualified name.

=== Example 1: A User-defined Struct ===

This example shows how you may define and use a struct, and how to reference the items within it, both with and without <tt>With</tt>. Either way, the names of the data fields (from the <tt>Type</tt> definition) must be qualified by the name of the instance (from the <tt>Dim</tt> statement).

<source lang="oobas">
Type aMenuItem
aCommand as String
aText as String
End Type

Sub Main
'Create an instance of the user-defined struct.
' Note the keyword, "New".
Dim maItem as New aMenuItem
With maItem
.aCommand = ".uno:Copy"
.aText = "~Copy"
End With

MsgBox "Command: " & maItem.aCommand & Chr(13) _
& "Text: " & maItem.aText
End Sub
</source>

=== Example 2: Case statement ===

In [[EN/documentation/basic_guide/cells_and_ranges|Cells and Ranges]], the following example has the qualifiers in the <tt>Case</tt> statements written out completely, for clarity. You can write it more easily, this way:

<source lang="oobas">
Dim Doc As Object
Dim Sheet As Object
Dim Cell As Object

Doc = ThisComponent
Sheet = Doc.Sheets(0)
Cell = Sheet.getCellByPosition(1,1) 'Cell "B2" (0-based!)

Cell.Value = 1000

With com.sun.star.table.CellContentType
Select Case Cell.Type
Case .EMPTY
MsgBox "Content: Empty"
Case .VALUE
MsgBox "Content: Value"
Case .TEXT
MsgBox "Content: Text"
Case .FORMULA
MsgBox "Content: Formula"
End Select
End With
</source>
Notice that the <tt>With</tt> construct must be entirely outside of the <tt>Select</tt> construct.

{{PDL1}}

EN/documentation/basic guide/other instructions - Revision history

Sancho: Created page with "{{DISPLAYTITLE:Other Instructions}}{{BreadCrumbL10n}} {{Documentation/BASICGuideTOC |Sh..."

Sancho: Created page with "
{{DISPLAYTITLE:Other Instructions}}
{{BreadCrumbL10n}} {{Documentation/BASICGuideTOC |Sh..."