# Tutorial 1: Omnis Kickstart - Von Null zum ersten Verstaendnis

**Dauer**: ca. 30 Minuten
**Voraussetzung**: Grundkenntnisse in irgendeiner Programmiersprache (JS, Python, VB, C#, Java...)
**Ziel**: Du verstehst die Grundstruktur von Omnis und kannst einfachen Code lesen

---

## 1. Was ist Omnis Studio?

Stell dir vor: Visual Studio + Access + Node.js in einem Tool. Das ist Omnis.

| Was du kennst | Omnis-Aequivalent |
|---------------|-------------------|
| VS Code / IDE | Omnis Studio IDE (integriert) |
| .sln / Projekt | Library (.lbs Datei) |
| Klassen / Dateien | Classes (in der Library) |
| Funktionen | Methods |
| npm packages | Externe Libraries |
| HTML/React | Windows (Desktop) oder Remote Forms (Web) |
| SQL Workbench | Eingebauter SQL Browser |

**Der groesste Unterschied:** Omnis ist eine **Kommando-basierte Sprache**, keine Expression-basierte. Jede Zeile beginnt mit einem Befehl.

---

## 2. Die Sprache: Befehle statt Ausdruecke

### In JavaScript:
```javascript
let name = "Harry";           // Deklaration + Zuweisung
let total = price * quantity;  // Ausdruck
console.log(name);            // Funktionsaufruf
```

### In Omnis:
```omnis
Calculate lName as "Harry"           ;; Zuweisung mit dem Befehl "Calculate"
Calculate lTotal as lPrice * lQty    ;; Berechnung mit "Calculate"
OK message {[lName]}                 ;; Nachricht anzeigen (wie alert/console.log)
```

**Merke:**
- `Calculate` = "Berechne und weise zu"
- Variablen haben Praefix: `l` = lokal, `i` = Instanz, `t` = Task, `p` = Parameter
- `;;` oder `#` fuer Kommentare
- `{[variable]}` fuer String-Interpolation in Texten

---

## 3. Variablen: Das Praefix-System

In Omnis hat JEDE Variable einen Praefix, der ihren **Scope** anzeigt:

| Praefix | Scope | Wie in JS/Python |
|---------|-------|-----------------|
| `l` | Lokal (nur diese Methode) | `let x` / lokale Variable |
| `i` | Instanz (dieses Objekt) | `this.x` / `self.x` |
| `t` | Task (globale Session) | Globale Variable |
| `p` | Parameter (Eingabe) | Funktionsparameter |
| `c` | Klassen-Variable (statisch) | `static` / Klassenvariable |

```omnis
# Beispiel: Methode mit Parameter und lokaler Variable
Calculate lFullName as con(pFirstName, " ", pLastName)
Calculate iCustomerName as lFullName    ;; In Instanz-Var speichern
```

**Uebung 1:** Was ist der Scope dieser Variablen?
- `lCounter` -> ???
- `iOrderList` -> ???
- `tCurrentUser` -> ???
- `pAmount` -> ???

<details>
<summary>Loesung</summary>

- `lCounter` -> Lokal (nur in der aktuellen Methode)
- `iOrderList` -> Instanz (gehoert zum Objekt)
- `tCurrentUser` -> Task (global in der Session)
- `pAmount` -> Parameter (wurde der Methode uebergeben)

</details>

---

## 4. Datentypen

| Omnis Typ | Konstante | Wie in JS |
|-----------|-----------|-----------|
| Character (String) | kCharacter | string |
| Integer | kInteger | number (int) |
| Number (Dezimal) | kNumber | number (float) |
| Boolean | kBoolean | boolean |
| Date | kDate | Date |
| List | kList | Array of Objects |
| Row | kRow | Object / Record |
| Object Reference | kObjectref | Referenz auf ein Objekt |

```omnis
# Variablen werden im IDE deklariert (nicht im Code!)
# Im IDE: Variable "lName" anlegen, Typ = Character
# Dann im Code:
Calculate lName as "Harry"
Calculate lAge as 42
Calculate lActive as kTrue
```

**Wichtig:** Variablen werden im Omnis IDE deklariert (wie in VB mit Dim), NICHT im Code!

---

## 5. Kontrollstrukturen

### If / Else
```omnis
;; JavaScript:  if (age >= 18) { ... } else { ... }
;; Omnis:
If lAge >= 18
  OK message {Erwachsen}
Else
  OK message {Minderjaehrig}
End If
```

### For-Schleife
```omnis
;; JavaScript:  for (let i = 1; i <= 10; i++) { ... }
;; Omnis:
For lCounter from 1 to 10 step 1
  Calculate lSum as lSum + lCounter
End For
```

### While-Schleife
```omnis
;; JavaScript:  while (condition) { ... }
;; Omnis:
While lCounter < 100
  Calculate lCounter as lCounter + 1
End While
```

### Switch/Case
```omnis
;; JavaScript:  switch(status) { case 'A': ... }
;; Omnis:
Switch lStatus
  Case 'A'
    # Aktiv
  Case 'I'
    # Inaktiv
  Default
    # Unbekannt
End Switch
```

**Uebung 2:** Uebersetze diesen JavaScript-Code in Omnis:
```javascript
let sum = 0;
for (let i = 1; i <= 100; i++) {
  if (i % 2 === 0) {
    sum += i;
  }
}
console.log("Summe: " + sum);
```

<details>
<summary>Loesung</summary>

```omnis
Calculate lSum as 0
For lI from 1 to 100 step 1
  If mod(lI, 2) = 0
    Calculate lSum as lSum + lI
  End If
End For
OK message {Summe: [lSum]}
```

</details>

---

## 6. Methoden (Funktionen)

In Omnis sind Methoden immer Teil einer Klasse (wie in Java/C#, nie wie freie Funktionen in JS/Python).

### Methode aufrufen:
```omnis
;; JavaScript:  let result = myObject.calculate(10, 20);
;; Omnis:
Do iMyObject.$calculate(10, 20) Returns lResult
```

### Das `Do` Kommando:
- `Do` = "Fuehre aus" (wie ein Funktionsaufruf)
- `$methodname` = Dollar-Praefix fuer Methoden
- `Returns lVar` = Fange den Rueckgabewert auf

### Methode definieren (im IDE):
Methoden werden im Omnis IDE erstellt, nicht im Code deklariert.
```omnis
# Methode "$calculate" mit Parametern pA, pB:
Calculate lResult as pA + pB
Quit method lResult    ;; = return lResult
```

---

## 7. Die $-Notation: Das Herz von Omnis

Das ist DER groesste Unterschied zu allen anderen Sprachen. In Omnis adressierst du ALLES ueber Dollar-Pfade:

```omnis
;; Objekt-Property lesen:
Calculate lVal as $cinst.$objs.myField.$contents

;; Aufgeschluesselt:
;; $cinst        = aktuelle Instanz (= this)
;; .$objs        = alle UI-Objekte darauf
;; .myField      = das Feld namens "myField"
;; .$contents    = dessen Inhalt
```

### Die wichtigsten $-Pfade:

| Pfad | Bedeutung | JS-Aequivalent |
|------|-----------|----------------|
| `$cinst` | Aktuelle Instanz | `this` |
| `$cclass` | Aktuelle Klasse | `this.constructor` |
| `$clib` | Aktuelle Library | - |
| `$ctask` | Aktueller Task | - |
| `$objs` | UI-Objekte auf einem Window | `document.querySelectorAll` |
| `$contents` | Wert/Inhalt | `.value` / `.textContent` |
| `$visible` | Sichtbarkeit | `.style.display` |
| `$enabled` | Aktiv/Inaktiv | `.disabled` |

### Property SETZEN (nicht = sondern $assign!):
```omnis
;; JavaScript:  element.style.display = 'none';
;; Omnis:
Do $cinst.$objs.myField.$visible.$assign(kFalse)

;; JavaScript:  element.value = "Hello";
;; Omnis:
Do $cinst.$objs.myField.$contents.$assign("Hello")
```

**Das ist anfangs verwirrend, wird aber schnell natuerlich!**

---

## 8. Zusammenfassung: Die 7 goldenen Regeln

1. **Jede Zeile ist ein Befehl**: `Calculate`, `Do`, `If`, `For`, etc.
2. **Variablen haben Scope-Praefixe**: `l`okal, `i`nstanz, `t`ask, `p`arameter
3. **$ ist ueberall**: Methoden, Properties, Pfade - alles mit Dollar
4. **$assign() zum Setzen**: Nie `=` fuer Notation-Properties
5. **Variablen werden im IDE deklariert**: Nicht im Code
6. **`Do` fuer Aufrufe, `Calculate` fuer Berechnungen**: Die zwei Hauptbefehle
7. **`Returns` / `#F` fuer Ergebnisse**: Rueckgabewerte und der globale Flag

---

## Mini-Quiz: Teste dich selbst!

**Frage 1:** Was macht dieser Code?
```omnis
Calculate lList as $cinst.$objs.orderGrid.$dataname
```

**Frage 2:** Wie liest man die `$visible`-Property eines Feldes namens "btnSave"?

**Frage 3:** Was ist der Unterschied zwischen `Calculate` und `Do`?

<details>
<summary>Antworten</summary>

1. Holt den Datennamen (= gebundene Variable) des UI-Elements "orderGrid" auf der aktuellen Instanz.
2. `Calculate lVisible as $cinst.$objs.btnSave.$visible`
3. `Calculate` = Berechnung/Zuweisung, `Do` = Methodenaufruf/Befehlsausfuehrung

</details>

---

**Naechstes Tutorial:** [02 - Notation Mastery](02-notation-mastery.md) - Tiefer eintauchen in das $-Notationssystem