Aufrufinformation

Variant = My.GetCodeData(tcCode AS STRING , tcP1 AS STRING , tcP2 AS STRING , tcP3 AS STRING , tcP4 AS STRING)
Variant = My.GetCodeData(tcCode,tcP1,tcP2,tcP3,tcP4)

Codeinformation

*/ Codebeispiel, My wird vorausgesetzt...
*/ 1. Wir haben die Vorgangsposition und möchten den Kontinent des Herstellers des Artikels wissen
LOCAL lcKontinent AS String
lcKontinent = My.GetCodeData("to.c07[to.c09[to.c62[to.b01['%P1%'].idc62].idc09].idc07].bezei",e11.idb01)

*/ Wir wandeln das obige Baispiel in einzelnen Abschnitte um:
*/ Die obige Formel wird von Innen nach Außen abgearbeitet:
xIdc62 = My.Bussines.Strain.Misc.oB01[e11.idb01].idc62			&& xIdc62 = to.b01['%P1%'].idc62
xIdc09 = My.Bussines.Strain.Misc.oC62[xIdc62].idc09				&& xIdc09 = to.c62[xIdc62].idc09
xIdc07 = My.Bussines.Strain.Misc.oC09[xIdc09].idc07				&& xIdc07 = to.c09[xIdc09].idc07
lcKontinent = My.Bussines.Strain.Misc.oC07[xIdc07].bezei		&& lcKontinent = to.c07[xIdc07].bezei

*/ to steht für: My.Bussines.Strain.Misc
*/ Nachfolgend die Tabelle getrennt durch "." .b01 => .oB01
*/ Danach kommt die ID der Tabelle als Parameter in eckigen Klammern: [e11.idb01]
*/ Jetzt benötigen wird nur noch der Rückgabewert getrennt durch "." .idc62
*/ Die Funktion in Erklärung:
*/	TableObject(to).Table(b01)['Primärschlüssel'].Feldname(idc62)
*/ Durch die kurze Schreibweise kann man auch lange Verschachtelungen erzeugen...

*/ Wenn man eine Funktion zusammensetzen muss:
LOCAL lcKontinent AS String
lcKontinent = My.GetCodeData(My.GetCodeData("to.c07[to.c09[to.c62[to.b01[to.i20[[idd40+idd51='%P1%%P2%']].idb01].idc62].idc09].idc07].bezei",d51.idd40,d51.idd51)
*/ MAN ACHTE AUF DIE DOPPELKLAMMER INNERHALB to.i20[[...Funktion...]].idb01

*/ Falls man nur die Artikelnummer hat:
LOCAL lcKontinent AS String
lcKontinent = My.GetCodeData("to.c07[to.c09[to.c62[to.b01[[artnr='%P1%']].idc62].idc09].idc07].bezei",e11.artnr)

*/ Wenn man das Objekt benötigt:
LOCAL loC07 AS Object
loC07 = My.GetCodeData("to.c07[to.c09[to.c62[to.b01['%P1%'].idc62].idc09].idc07]",e11.idb01)
*/ oder...
loC07 = My.GetCodeData(My.GetCodeData("to.c07[to.c09[to.c62[to.b01[to.i20[[idd40+idd51='%P1%%P2%']].idb01].idc62].idc09].idc07]",d51.idd40,d51.idd51)
*/ oder...
loC07 = My.GetCodeData("to.c07[to.c09[to.c62[to.b01[[artnr='%P1%']].idc62].idc09].idc07]",e11.artnr)
*/ loC07 ist ein Objekt des Datensatzes der Tabelle C07!

*/ Der Verschachtelte Datenabruf in einem Datenraster (Spezialspalte)
*/ Die Funktion ist mit 'gleichem' Aufruf auch in Main gespeichert!
_kon=GetCodeData("to.c07(to.c09(to.c62(to.b01(to.i20("+'"idd40+idd51='+"'%P1%%P2%'"+'"'+").idb01).idc62).idc09).idc07).bezei",d51.idd40,d51.idd51)
*/ Mit einer Funktion als Parameter wird die Sache triggi...
*/ Obige Funktion wird in den Datenraster Tabellen X60/X61/X62 in eckigen Klammern als String gespeichert, weshalb keine solche Klammern verwendet werden dürfen.
ControlSource = [_kon=GetCodeData("to.c07(to.c09(to.c62(to.b01(to.i20("+'"idd40+idd51='+"'%P1%%P2%'"+'"'+").idb01).idc62).idc09).idc07).bezei",d51.idd40,d51.idd51)]
wait window m.ControlSource
*/ Es geht auch einfacher und schneller...
_kon=GetCodeData("to.c07(to.c09(to.c62(to.b01('%P1%).idc62).idc09).idc07).bezei",d51.idb01)

Hilfeinformation

Variant = My.GetMiscData(tcObj AS STRING,tcId AS STRING,tcField AS STRING,tvP2 AS Variant,tvP3 AS Variant,tvP4 AS Variant,tvP5 AS Variant)
Variant = My.GetMiscData(tcObj,tcId,tcField,tvP2,tvP3,tvP4,tvP5)

Variant = My.GetMiscValue(tcObj AS STRING,tcId AS STRING,tcField AS STRING)
Variant = My.GetMiscValue(tcObj,tcId,tcField)

Collection = My.GetParameters(tvP1 AS Variant,tvP2 AS Variant,tvP3 AS Variant,tvP4 AS Variant,tvP5 AS Variant,tvP6 AS Variant,tvP7 AS Variant,tvP8 AS Variant,tvP9 AS Variant)
Collection = My.GetParameters(tvP1,tvP2,tvP3,tvP4,tvP5,tvP6,tvP7,tvP8,tvP9)

*/ Hier können mehrere Parameter in eine Collection übertragen werden
LOCAL loCollection AS Collection , lni AS Integer , lcNames AS String
loCollection = My.GetParameters(1,DATE(),TIME())
WAIT WINDOW m.loCollection.Count		&& Anzahl der Werte (3)
*/ Die Namen der Parameter bestimmen
lcNames = ""
FOR m.lni = 1 TO m.loCollection.Count
	lcNames = m.lcNames + ";" + m.loCollection.GetKey(m.lni)
NEXT m.lni
WAIT WINDOW SUBSTR(m.lcNames,2)

Collection = My.GetParametersCount(tnCnt AS Number,tvP1 AS Variant,tvP2 AS Variant,tvP3 AS Variant,tvP4 AS Variant,tvP5 AS Variant,tvP6 AS Variant,tvP7 AS Variant,tvP8 AS Variant,tvP9 AS Variant)
Collection = My.GetParametersCount(tnCnt,tvP1,tvP2,tvP3,tvP4,tvP5,tvP6,tvP7,tvP8,tvP9)

*/ Hier können mehrere Parameter in eine Collection übertragen werden
*/ Als Beispiel kann nur der Aufruf eines Scripts / einer Methode dienen
LPARAMETERS tp1 AS Variant , tp2 AS Variant , tp3 AS Variant 	&& Es könnten mehr sein!
LOCAL loCollection AS Collection , lni AS Integer
lni = PCOUNT()		&& Wieviele Parameter wurden übergeben?
loCollection = My.GetParametersCount(m.lni,m.tp1,m.tp2,m.tp3)
WAIT WINDOW m.loCollection.Count		&& Anzahl der Werte (?)

String = My.GetStackLog(tlLine AS Boolean)
String = My.GetStackLog(tlLine)

String = My.GetStckShort(tnDeep AS Integer)
String = My.GetStckShort(tnDeep)

Variant = My.GetSwitchValue(tcIP AS String,tcID AS String)
Variant = My.GetSwitchValue(tcIP,tcID)

Boolean = My.LogTextAdd(tvValue AS Variant)
Boolean = My.LogTextAdd(tvValue)

=My.LogTextAdd("Dies ist ein Test...")
? My.LogsCount
IF My.LogsCount>0
	? My.aLogs[1,1],My.aLogs[1,2],My.aLogs[1,3]
	*/ Struktur von My.aLogs[n,3]
	*/ [n,1] = "C" - Text
	*/ [n,2] = "T" - DateTime()
	*/ [n,3] = "N" - Seconds()
ENDIF

Variant = My.MirrorValues(tvValue1 AS Variant @,tvValue2 AS Variant @)
Variant = My.MirrorValues(@tvValue1,@tvValue2)

*/ Beispiel
LOCAL lvValue1 AS Variant, lvValue2 AS Variant
lvValue1 = "Michael"
lvValue2 = DATE()
=My.MirrorValues(@lvValue1,@lvValue2)
? lvValue1		&& Enthält DATE()
? lvValue2		&& Enthält "Michael"

Variant = My.MirrorValuesR(tvValue1 AS Variant @,tvValue2 AS Variant @,tlSecondValue AS Boolean)
Variant = My.MirrorValuesR(@tvValue1,@tvValue2,tlSecondValue)

*/ Beispiel:
LOCAL lvValue1 AS Variant , lvValue2 AS Variant

lvValue1 = "Michael"
lvValue2 = DATE()
*/ Rückgabe von lvValue2 also Date
? My.MirrorValuesR(@lvValue1,@lvValue2,.F.)

lvValue1 = "Michael"
lvValue2 = DATE()
*/ Rückgabe von lvValue1 also Michael
? My.MirrorValuesR(@lvValue1,@lvValue2,.T.)

*/ Anmerkung: Die Inhalte werden erst getauscht, danach wird entschieden, welche Variable zurückgegeben wird.

Variant = My.ReadFieldInit(toField AS TEXTBOX)
Variant = My.ReadFieldInit(toField)

Variant = My.ResetBufferedInfos(tvWhat AS Variant)
Variant = My.ResetBufferedInfos(tvWhat)

Variant = My.SetParameters(toPara AS Collection,tvP1 AS Variant @,tvP2 AS Variant @,tvP3 AS Variant @,tvP4 AS Variant @,tvP5 AS Variant @,tvP6 AS Variant @,tvP7 AS Variant @,tvP8 AS Variant @,tvP9 AS Variant @)
Variant = My.SetParameters(toPara,@tvP1,@tvP2,@tvP3,@tvP4,@tvP5,@tvP6,@tvP7,@tvP8,@tvP9)

*/ Umwandeln einer Collection in Parameter
LOCAL loCollection AS Collection,lnVar1 AS Number,lnVar2 AS Number
loCollection = CREATEOBJECT("Collection")
=loCollection.Add(1,"tvp1")
=loCollection.Add(2,"tvp2")
=My.SetParameters(m.loCollection,@lnVar1,@lnVar2)
WAIT WINDOW m.lnVar1
WAIT WINDOW m.lnVar2

Logical = My.SetValue(tvVonValue AS Variant , RvAnValue AS Variant @)
Logical = My.SetValue(tvVonValue,@RvAnValue)

*/ Beispiel:
LOCAL cValue AS String
=My.SetValue("Michael"+" "+"Bergner",@cValue)
WAIT WINDOW cValue

*/ Diese Funktion kan in CASE ... ENDCASE Konstrukten genutzt werden!
*/ Beispiel:
LOACL vValue1,vValue2
DO CASE
	CASE !My.SetValue("Michael",@vValue1)
		* Kommt hier nie an!
	CASE ...
	CASE !My.SetValue(DATE(),@vValue2)
		* Kommt hier nie an!
	CASE ...
	OTHERWISE
		...
ENDCASE

Variant = My.SetValueR(tvVonValue AS Variant , RvAnValue AS Variant @)
Variant = My.SetValueR(tvVonValue,@RvAnValue)

*/ Beispiel:
LOCAL lnZahl AS Number
IF My.SetValueR(2+3,@lnZahl)>=5
	*/ Ist...
ELSE
	*/ Ist nicht...
ENDIF

Variant = My.SuspendPms(tlDebugger AS Boolean,tlSession AS Boolean)
Variant = My.SuspendPms(tlDebugger,tlSession)

Variant = My.TVL(tvValue AS Variant , tvDefault AS Variant , tlNullAsDefault AS Boolean)
Variant = My.TVL(tvValue,tvDefault,tlNullAsDefault)

*/ Ein Beispiel
LOCAL lvReturn AS Variant
*/ Ausgabe 25
WAIT WINDOW My.TVL('',25)
*/ Ausgabe 33
WAIT WINDOW My.TVL(33,25)
*/ Ausgabe 44
WAIT WINDOW My.TVL(.NULL.,44,.T.)

Variant = My.TYVL(tcVariable AS String,tvDefault AS Variant, tlNullAsDefault AS Boolean)
Variant = My.TYVL(tcVariable,tvDefault,tlNullAsDefault)

*/ Diese Funktion ist der Funktion TVL ähnlich!
*/ Beispiel:

PRIVATE pcTest AS String
pcTest = "Michael"

*/ Ausgabe 25
WAIT WINDOW My.TYVL("m.pcTest",25,.T.)

*/ HINWEIS: Die angegebene Variable MUSS als PUBLIC oder PRIVATE deklariert sein!

String = My.TestDirectory(tcDir AS String,tlEmpty AS Boolean,tlCreate AS Boolean)
String = My.TestDirectory(tcDir,tlEmpty,tlCreate)

LOCAL lcDir
lcDir = My.TestDirectory("c:\tmp\test1\",.T.,.T.)
IF !EMPTY(m.lcDir)
	*/ Dann wurde das Verzeichnis angelegt!
ENDIF
*/ Hinweis!
*/ Wird der zweite Parameter mit .F. angegeben und konnte das Verzeichnis NICHT angelegt werden, so wird:
lcDir = "*c:\tmp\test1\"
*/ zurückgegeben! Der * am Anfang signalisiert dann, dass das Verzeichnis nicht existiert bzw.
*/ nicht angelegt werden konnte.

,cInfo = My.TimeCheck(SECONDS_ AS NUMBER,tvValue AS Variant,tcInfo AS STRING)
,cInfo = My.TimeCheck(SECONDS_,tvValue,tcInfo)

,cInfo = My.TimeWrite(tcFile AS String,tcInfo AS String)
,cInfo = My.TimeWrite(tcFile,tcInfo)

Variant = My.Wait(tnSeconds AS NUMBER)
Variant = My.Wait(tnSeconds)

*/ Beispiel...
? TIME()
=My.Wait(3)
*/ Wartet 3 Sekunden bevor der Befehl abgearbeitet wird
? TIME()
*/ HINWEIS:
*/ Diese Funktion funktioniert auch in einer NameSpace DLL!

Boolean = My.WaitWIndow(tv1,tv2)
Boolean = My.WaitWIndow(tv1,tv2)

Variant = My.WaitWhileFile(tcFile AS STRING,tnAttempts AS Number)
Variant = My.WaitWhileFile(tcFile,tnAttempts)

*/ Beispiel
LOCAL llNotFile
*/ Wir warten nur 5 Sekunden! Der zeite Parameter ist optional!
llNotFile = My.WaitWhileFile(My.Clients.Path.cTmpDir+'test.txt',5)
IF m.llNotFile
	? "Datei gibt es nicht (mehr)"
ELSE
	? "Die Datei ",My.Clients.Path.cTmpDir+'test.txt'," existiert noch!"
ENDIF

Variant = My.WriteBGLog(tcProgram AS String,tcText AS String)
Variant = My.WriteBGLog(tcProgram,tcText)

Variant = My.WriteFSLog(tcText AS STRING,tlOffset AS Boolean)
Variant = My.WriteFSLog(tcText,tlOffset)

Variant = My.WriteInLog(tcText AS STRING,tlNoDate AS Boolean,tcFile AS STRING,tlOverWrite AS Boolean)
Variant = My.WriteInLog(tcText,tlNoDate,tcFile,tlOverWrite)

*/ Ohne Datum/Zeit
=My.WriteInLog("Text",.T.,"MyOwn.log",.F.)
*/ Mit Datum/Zeit
=My.WriteInLog("Text",.F.,"MyOwn.log",.F.)
*/ Nur Zeit
=My.WriteInLog("Text",.NULL.,"MyOwn.log",.F.)

Boolean = My.WriteInLogIf(tcText AS STRING,tlNoDate AS Boolean,tcFile AS STRING,tlOverWrite AS Boolean)
Boolean = My.WriteInLogIf(tcText,tlNoDate,tcFile,tlOverWrite)

*/ Ohne Datum/Zeit
=My.WriteInLogIf("Text",.T.,"MyOwn.log",.F.)
*/ Mit Datum/Zeit
=My.WriteInLogIf("Text",.F.,"MyOwn.log",.F.)
*/ Nur Zeit
=My.WriteInLogIf("Text",.NULL.,"MyOwn.log",.F.)

Variant = My.WriteInSLog(tcText AS STRING,tcInfo AS String,tlNoDate AS Boolean,tcFile AS STRING,tlOverWrite AS Boolean)
Variant = My.WriteInSLog(tcText,tcInfo,tlNoDate,tcFile,tlOverWrite)

*/ Ohne Datum/Zeit
=My.WriteInSLog("Text","Info",.T.,"MyOwn.log",.F.)
*/ Mit Datum/Zeit
=My.WriteInSLog("Text","Info",.F.,"MyOwn.log",.F.)
*/ Nur Zeit
=My.WriteInSLog("Text","Info",.NULL.,"MyOwn.log",.F.)

Variant = My.WriteLog(tcText AS STRING,tlNoDate AS Boolean,tlOverWrite AS Boolean)
Variant = My.WriteLog(tcText,tlNoDate,tlOverWrite)

Variant = My.WriteLogIf(tcText AS STRING,tlNoDate AS Boolean,tlOverWrite AS Boolean)
Variant = My.WriteLogIf(tcText,tlNoDate,tlOverWrite)

Boolean = My.WriteLogText(tnWhat AS INTEGER,tcFile AS STRING)
Boolean = My.WriteLogText(tnWhat,tcFile)

Variant = My.WriteSameLog(tcText AS STRING,tlNoDate AS Boolean,tlOverWrite AS Boolean)
Variant = My.WriteSameLog(tcText,tlNoDate,tlOverWrite)

Variant = My.WriteSameLogIf(tcText AS STRING,tlNoDate AS Boolean,tlOverWrite AS Boolean)
Variant = My.WriteSameLogIf(tcText,tlNoDate,tlOverWrite)

Variant = My.WriteStackLogIf(tcProgram AS STRING)
Variant = My.WriteStackLogIf(tcProgram)

Variant = My._MenuClick(tvIndex1 AS Variant,tnIndex2 AS NUMBER)
Variant = My._MenuClick(tvIndex1,tnIndex2)

Variant = My._MenuEnabled(tvIndex1 AS Variant,tnIndex2 AS NUMBER)
Variant = My._MenuEnabled(tvIndex1,tnIndex2)

Variant = My.aMLic(tvIndex1 AS Variant,tnIndex2 AS NUMBER)
Variant = My.aMLic(tvIndex1,tnIndex2)

Variant = My.aMRights(tcForm AS STRING,tlAsInteger AS Boolean)
Variant = My.aMRights(tcForm,tlAsInteger)

*/ Beispiel
LOCAL lcRights AS String,liRights AS Integer
lcRights = My.aMRights("B0101",.F.)
liRights = My.aMRights("B0101",.T.)
*/ Rechte im String: (Entsprechende Stelle enthält "X")
*/	1 - Ansehen
*/	2 - Ändern
*/	3 - Neuanlage
*/	4 - Löschen
*/	5 - Drucken
*/ Gilt auch für den Integerwert: (Entspechende Stelle enthält 1)
IF BITTEST(m.liRights,1)
	*/ Dann darf er zumindest ansehen...
ENDIF

Boolean = My.lEndForm(toForm AS Form)
Boolean = My.lEndForm(toForm)

Variant = My.oIm(tcS AS STRING,toT AS OBJECT,tcN AS STRING,tlId AS Boolean,tvp1,tvp2,tvp3,tvp4,tvp5,tvp6,tvp7,tvp8,tvp9)
Variant = My.oIm(tcS,toT,tcN,tlId,tvp1,tvp2,tvp3,tvp4,tvp5,tvp6,tvp7,tvp8,tvp9)

Variant = My.oImh(tcS AS STRING,toT AS Object,tcN AS String,tlId AS Boolean,tvp1,tvp2,tvp3,tvp4,tvp5,tvp6,tvp7,tvp8,tvp9)
Variant = My.oImh(tcS,toT,tcN,tlId,tvp1,tvp2,tvp3,tvp4,tvp5,tvp6,tvp7,tvp8,tvp9)

Variant = My.oIn(tcS AS STRING,toT AS Object,tcN AS String,tlId AS Boolean,tvp1,tvp2,tvp3,tvp4,tvp5,tvp6,tvp7,tvp8,tvp9)
Variant = My.oIn(tcS,toT,tcN,tlId,tvp1,tvp2,tvp3,tvp4,tvp5,tvp6,tvp7,tvp8,tvp9)

Boolean = My.LBGPlog

Object = My.OutFHTM

Object = My.PrivateSession

LOCAL loSession AS DataSession
loSession = My.PrivateSession

String = My.ScriptFile

*/ ScriptFile wird eigentlich intern benötigt!
*/ Hier nur ein Beispiel...
*/ My sollte bekannt sein...
My.ScriptFile = "MeineScriptDatei.Define"		&& Die Datei muss in sys\mysys\ existieren!
*/ Zuweisen der Mandanten-ID
My.cIdx02 = My.cIdx02

String = My._ComClsId

Number = My._Datasession

String = My._LogDir

String = My._LogFile

Boolean = My._MenuesItem[tcIndex1 AS String | tiIndex1 AS Integer , tiIndex2 AS Integer]
Boolean = My._MenuesItem[tcIndex1|,tiIndex1,tiIndex2]

LOCAL llEnabled
llEndabled = My._MenusItem("SYSMENU._PRECORD._SAVE.Enabled")

String = My._Name

LOCAL lcComName AS String
lcComName = My._Name
WAIT WINDOW m.lcComName

String = My._Path

Number = My._StartMode

*/ Abfrage des Modus
WAIT WINDOW My._StartMode

Number = My._StartNumber

String = My._Terminal

LOCAL lcTerminal
lcTerminal = UPPER(ALLTRIM(GETWORDNUM(SYS(0),1,"#")))
IF m.lcTerminal==My._Terminal
	*/ Dann wars korrekt berechnet...
ENDIF

String = My._User

LOCAL lcUser
lcUser = UPPER(ALLTRIM(GETWORDNUM(SYS(0),2,"#")))
IF m.lcUser==My._User
	*/ Dann wars korrekt berechnet...
ENDIF

String = My._Version

WAIT WINDOW My._Version

String = My._VfpVersion

WAIT WINDOW My._VfpVersion

Boolean = My._lComStart

Array = My.aLogs[tiIndex1 AS Integer , tiIndex2 AS Integer]
Array = My.aLogs[tiIndex1,tiIndex2]

Array = My.aLogsCount

Array = My.aTimes[tiIndex1 AS Integer , tiIndex2 AS Integer]
Array = My.aTimes[tiIndex1,tiIndex2]

Array = My.aTimesCount

String = My.cBrowFor

LOCAL lcFilter
lcFilter = My.cBrowFor

String = My.cClassHelp

String = My.cIdc26

WAIT WINDOW My.cIdc26

String = My.cIdc26R

String = My.cIdx02

*/ Abfrage der Mandanten-ID
WAIT WINDOW My.cIdx02

*/ Wenn man mittels VFP Zugriff auf die Applikation braucht:

*/ 1. vfp9.exe öffenen
*/ 2. In das Startverzeichnis von PMS32 wechseln (MUSS)
CD c:\pms\pms32
*/ 3. My Instanziieren
My = NEWOBJECT("pmsmy","pmsmyhandler.vcx","pmsmyhandler.app")
*/ 4. Den letzten aktuellen Mandanten zuweisen
My.cIdx02 = My.cIdx02
*/ 5. Los gehts...

String = My.cLogTextAdd

String = My.cMethod

*/ Abruf...
WAIT WINDOW My.cMethod

String = My.cPmsOtherLicFile

String = My.cPmsVersion

String = My.cResetInfos

*/ Verschiedene RESET Befehle...
My.cResetInfos = "REMOVE-MENUES"
My.cResetInfos = "REMOVE-CS-FILES"
My.cResetInfos = "REMOVE-CS-SCRIPTS"
My.cResetInfos = "CHANGE-IDX09"
My.cResetInfos = "USER_LOGIN"
*/ Je nach Klasse wird ein entsprechender RESET ausgeführt!

String = My.cSys2015

*/ Beispiel:
? My.cSys2015
? My.cSys2015
? My.cSys2015
*/ Die Rückgabe ist vom Typ: String und hat IMMER 10 Stellen
*/ Kann genommen werden, wenn für temporäre Cursor eine temporäre ID benötigt wird...
CREATE CURSOR temp (_id C(10))
INSERT INTO temp (_id) VALUES (My.cSys2015)
INSERT INTO temp (_id) VALUES (My.cSys2015)
INSERT INTO temp (_id) VALUES (My.cSys2015)
BROWSE

String = My.cTerminal

String = My.cUser

WAIT WINDOW My.cUser

Number = My.fxUsr

*/ Gibt einen Schlüssel für Terminal-User-MANDANT-SYS(2015) zurück. Eindeutiger Schlüssel
*/ TTTTT-UUUUU-MMMMM-SSSSSSSSS : 27 Stellen...

Boolean = My.lChange

Boolean = My.lChild

*/ Nur sinnvoll innerhalb von PMS32
PRIVATE Child AS String
Child = .NULL.
? My.lChild
Child = "E11"
? My.lChild

Boolean = My.lENVlog

Boolean = My.lEditGridColumns

Boolean = My.lEnd

Boolean = My.lEndAll

*/ Beispiel...
IF !My.lEndAll
	*/ Hier kann weitergearbeitet werden
ENDIF

Boolean = My.lEplanLog

Boolean = My.lEraseClass

Boolean = My.lFormStackLog

Boolean = My.lGrid

Boolean = My.lGridLog

Boolean = My.lHasGUI

IF My.lHasGui
	*/ Funktioniert nur dann wenn ein GUI besteht!
	WAIT WINDOW "Hallo Welt..."
ENDIF

Boolean = My.lInDialog

Boolean = My.lIsJSOn

Boolean = My.lIsTheme

Boolean = My.lIsVfp2C32

Boolean = My.lLookupChildRelation

String = My.lMaster

LOCAL lcMaster
lcMaster = My.lMaster
IF !EMPTY(m.lcMaster)
	SELECT (m.lcMaster)
	*/ ...
ENDIF

Boolean = My.lMyReadCheck

Boolean = My.lNoAutoLogon

IF !My.lNoAutoLogon
	*/ Dann soll eine automatik Funktion ausgeführt werden.
ENDIF

Boolean = My.lNotUseDynamicValues

Boolean = My.lPmsCompatiple

Boolean = My.lPmsRemoteServer

Boolean = My.lProcessServerRunning

String = My.lProgram

Boolean = My.lReleaseAlwaysMenus

Boolean = My.lRunTime

IF NOT My.lRunTime
	*/ Dann könnte hier z.B. ein SUSPEND erfolgen
ENDIF

Boolean = My.lRushMore

Boolean = My.lSetPath

*/ Schlecht:
SELECT b01.* FROM b01 WHERE ...
*/ Besser:
SELECT b01.* FROM (My.Clients.Path.cDbfDir+'b01.dbf') WHERE ...
*/ Man kann auch über den SQL Handler gehen....
LOCAL lcSql
TEXT TO m.lcSql NOSHOW TEXTMERGE PRETEXT 3
SELECT b01.* FROM CDBFDIR!B01 AS b01 WHERE ...
ENDTEXT
IF My.Clients.Sql.SqlRead(SET("DataSession"),m.lcSql,"qB01")
	*/ Dann haben wir den Cursor aus B01 (qB01) am Wickel...
ENDIF

Boolean = My.lSuspendPms

Boolean = My.lSysmenuEnabled

Boolean = My.lTimerStop

My.lTimerStop = .T.
*/ Jetzt stehen alle Systemtimer still
My.lTimerStop = .F.
*/ Nicht vergessen, sonst steht PMS32!

Boolean = My.lVfpOriginalStatusBar

Boolean = My.lWriteLog

*/ Nur kurzzeitig ein Log mitschreiben
My.lWriteLog = .T.
=MenuHit("E4101")
My.lWriteLog = .F.

Boolean = My.lWritelogSUM

Boolean = My.llMaster

*/ Diese Property wird eigentlich nur intern verwendet...
*/ Trotzdem ein Beispiel:
PRIVATE Master AS STring
Master = .NULL.
? My.llMaster
Master = "B01"
? My.llMaster

Number = My.nCounter

Number = My.nError

WAIT WINDOW My.nError

Number = My.nFormSetLog

Number = My.nLine

WAIT WINDOW My.nLine

Number = My.nStackCount

Number = My.nlChange

Object = My.oCollection

*/ Beispiel:
LOCAL loColl AS Collection,lReturn AS Boolean
loColl = My.oCollection

*/ Adden mit Prüfung
lReturn = loColl.AddCheck(DATE(),"KEY1")		&& Sollte .T. zurückgeben

*/ Nochmals
lReturn = loColl.AddCheck(DATETIME(),"KEY1")	&& Sollte .F. zurückgeben

loColl.Clear()									&& Alle Inhalte löschen

*/ Anmerkung: Ansonsten sind alle Methoden und Properties einer Collection vorhanden!

Object = My.oException

*/ Beispiel:
LOCAL loException AS Exception
TRY
	i = j		&& Erzeugt einen Fehler!
CATCH TO loException
	*/ Fehlerdetails vervollständigen
	loException.Details = "Erzwungener Fehler!"
	*/ Und den Fehler speichern (Auch im Errorlog!)
	My.oException = m.loException
ENDTRY

Object = My.oKeys

Object = My.oMisc

Object = My.oPictures

Object = My.oXml

*/ Die obigen Funktionen werden über:
My.Functions.Xml.... aufgerufen

String = My.txUSR

*/ Beispiel:
LOCAL lcTx AS String
lcTx = My.txUsr
WAIT WINDOW m.lcTx

*/ Anmerkung:
*/ Obiger String wird aus den Werten My._Terminal + My._User gebildet!
*/ Diese beiden Werte werden aus den Teilen von SYS(0) beim Instanziieren von My gebildet
*/ ._Terminal = UPPER(ALLTRIM(GETWORDNUM(SYS(0),1,"#")))
*/ ._User     = UPPER(ALLTRIM(GETWORDNUM(SYS(0),2,"#")))
*/ Aus beiden Teilen wird eine maximal 5-stellige Checksumme gebildet, die zurückgegeben wird.

"Varname" = My.vVarHolder[tcIndex1 AS String | tiIndex1 AS Integer , tiIndex2 AS Integer]
"Varname" = My.vVarHolder[tcIndex1|,tiIndex1,tiIndex2]

*/ Beispiel:
LOCAL lvVariable AS Variant
lvVariable = CREATEOBJECT("Collection")		&& Wir nehmen eine Collection...

*/ Zuweisen der Variablen
My.vVarHolder['MeineVariable'] = m.lvVariable
*/ Existiert obiger Eintrag: 'MeineVariable' so wird der Wert überschrieben!
*/ Der VarHolder macht KEINEN Unterschied in Groß-/Kleinschreibung!
*/ MeineVariable = MEINEVARIABLE = meinevariable!

*/ Abruf der Information
lvVariable = My.vVarholder['MeineVariable']

*/ Ein spezieller Abruf, hier wird die VarHolder-Collection komplett abgerufen!
LOCAL loVarHolder AS Collection
*/ Abruf der kompletten Collection...
loVarHolder = My.vVarHolder[1]
*/ Gibt es einen Eintrag? (In der Collection wird der Variablenname in UPPER gespeichert!)
IF loVarHolder.GETKEY('MEINEVARIABLE')>0
	*/ Wenn die Variable existiert, dann löschen wir den Eintrag!
	=loVarHolder.REMOVE('MEINEVARIABLE')
ENDIF

*/ Anmerkung:
*/ vVarHolder['...'] gibt .NULL. zurück, wenn der Variablenname nicht gefunden wird!
*/ Beispiel:
lvVariable = My.vVarHolder['IstNichtDefiniert']
? lvVariable	&& Solle .NULL. sein...

*/ Anmerkung:
*/ Wenn man einen Eintrag löschen möchte...
My.vVarHolder['MeineVariable'] = .NULL.

Date = My.xDate

*/ Beispiel:
LOCAL ldDate AS Date
ldDate = My.xDate
WAIT WINDOW m.ldDate

DateTime = My.xDateTime

*/ Beispiel:
LOCAL ltDateTime AS DateTime
ltDateTime = My.xDateTime
WAIT WINDOW m.ltDateTime

Boolean = My.xNoChange

*/ Dieses Beispiel kann nur in PMS32 sinnvoll verwendet werden...

String = My.xProgram

*/ Dieses Beispiel kann nur in PMS32 sinnvoll verwendet werden...
*/ Trotzdem ein Beispiel:
PRIVATE l_program AS String
l_program = .NULL.		&& Ist damit nicht definiert...
? My.xProgram + '!'		&& !
l_program = 'TEST.PRG'
? My.xProgram + '!'		&& TEST.PRG!

Variant = My.xTag

String = My.xTime

*/ Beispiel:
LOCAL lcTime AS String
lcTime = My.xTime
WAIT WINDOW m.lcTime

String = My.yDate

*/ Beispiel:
LOCAL lcDate AS String
lcDate = My.yDate		&& Das heutige Datum in der Schreibweise YYYY-MM-DD
WAIT WINDOW m.lcDate