adjust to framework changes

FactoryCraft/AddServerMenu.cpp

@@ -1,110 +1,110 @@
 #include "AddServerMenu.h"
 
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 #include "ServerSelection.h"
 
-AddServerMenu::AddServerMenu(Bildschirm* zScreen)
+AddServerMenu::AddServerMenu(Screen* zScreen)
     : Menu(zScreen)
 {
-    Punkt center = zScreen->getBackBufferSize() / 2;
-    TextFeld* nameLabel = initTextFeld(center.x - 150,
+    Point center = zScreen->getBackBufferSize() / 2;
+    TextField* nameLabel = initTextField(center.x - 150,
         center.y - 50,
         100,
         20,
-        TextFeld::Style::Text | TextFeld::Style::VCenter,
+        TextField::Style::Text | TextField::Style::VCenter,
         "Name:");
     elements.add(nameLabel);
-    name = initTextFeld(nameLabel->getPosition().x + nameLabel->getBreite(),
+    name = initTextField(nameLabel->getPosition().x + nameLabel->getWidth(),
         nameLabel->getPosition().y,
         200,
         20,
-        TextFeld::Style::TextFeld,
+        TextField::Style::TextField,
         "");
-    name->setTastaturEreignis([this](void* p, void* o, TastaturEreignis te) {
+    name->setKeyboardEvent([this](void* p, void* o, KeyboardEvent te) {
         if (te.id == TE_Release && te.virtualKey == T_Tab)
         {
-            name->removeStyle(Zeichnung::Style::Fokus);
-            address->addStyle(Zeichnung::Style::Fokus);
+            name->removeStyle(Drawable::Style::Focus);
+            address->addStyle(Drawable::Style::Focus);
         }
         return te.virtualKey != T_Tab;
     });
     elements.add(name);
 
-    TextFeld* addressLabel = initTextFeld(center.x - 150,
+    TextField* addressLabel = initTextField(center.x - 150,
         center.y - 25,
         100,
         20,
-        TextFeld::Style::Text | TextFeld::Style::VCenter,
+        TextField::Style::Text | TextField::Style::VCenter,
         "Server Address:");
     elements.add(addressLabel);
-    address = initTextFeld(
-        addressLabel->getPosition().x + addressLabel->getBreite(),
+    address = initTextField(
+        addressLabel->getPosition().x + addressLabel->getWidth(),
         addressLabel->getPosition().y,
         200,
         20,
-        TextFeld::Style::TextFeld,
+        TextField::Style::TextField,
         "");
-    address->setTastaturEreignis([this](void* p, void* o, TastaturEreignis te) {
+    address->setKeyboardEvent([this](void* p, void* o, KeyboardEvent te) {
         if (te.id == TE_Release && te.virtualKey == T_Tab)
         {
-            address->removeStyle(Zeichnung::Style::Fokus);
-            sslPort->addStyle(Zeichnung::Style::Fokus);
+            address->removeStyle(Drawable::Style::Focus);
+            sslPort->addStyle(Drawable::Style::Focus);
         }
         return te.virtualKey != T_Tab;
     });
     elements.add(address);
 
-    TextFeld* sslPortLabel = initTextFeld(center.x - 150,
+    TextField* sslPortLabel = initTextField(center.x - 150,
         center.y,
         100,
         20,
-        TextFeld::Style::Text | TextFeld::Style::VCenter,
+        TextField::Style::Text | TextField::Style::VCenter,
         "SSL Server Port:");
     elements.add(sslPortLabel);
-    sslPort = initTextFeld(
-        sslPortLabel->getPosition().x + sslPortLabel->getBreite(),
+    sslPort = initTextField(
+        sslPortLabel->getPosition().x + sslPortLabel->getWidth(),
         sslPortLabel->getPosition().y,
         200,
         20,
-        TextFeld::Style::TextFeld,
+        TextField::Style::TextField,
         "");
-    sslPort->setTastaturEreignis([this](void* p, void* o, TastaturEreignis te) {
+    sslPort->setKeyboardEvent([this](void* p, void* o, KeyboardEvent te) {
         if (te.id == TE_Release && te.virtualKey == T_Tab)
         {
-            sslPort->removeStyle(Zeichnung::Style::Fokus);
-            port->addStyle(Zeichnung::Style::Fokus);
+            sslPort->removeStyle(Drawable::Style::Focus);
+            port->addStyle(Drawable::Style::Focus);
         }
-        return te.virtualKey != T_Tab && _nurNummernTE(p, o, te);
+        return te.virtualKey != T_Tab && _onlyNumbersTE(p, o, te);
     });
     elements.add(sslPort);
-    TextFeld* portLabel = initTextFeld(center.x - 150,
+    TextField* portLabel = initTextField(center.x - 150,
         center.y + 25,
         100,
         20,
-        TextFeld::Style::Text | TextFeld::Style::VCenter,
+        TextField::Style::Text | TextField::Style::VCenter,
         "Server Port:");
     elements.add(portLabel);
-    port = initTextFeld(portLabel->getPosition().x + portLabel->getBreite(),
+    port = initTextField(portLabel->getPosition().x + portLabel->getWidth(),
         portLabel->getPosition().y,
         200,
         20,
-        TextFeld::Style::TextFeld,
+        TextField::Style::TextField,
         "");
-    port->setTastaturEreignis(_nurNummernTE);
+    port->setKeyboardEvent(_onlyNumbersTE);
     elements.add(port);
 
-    add = initKnopf(
-        center.x + 50, center.y + 50, 100, 20, Knopf::Style::Normal, "Add");
-    add->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    add = initButton(
+        center.x + 50, center.y + 50, 100, 20, Button::Style::Normal, "Add");
+    add->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             if (name->zText()->getLength() && address->zText()->getLength()
                 && port->zText()->getLength())
             {
                 if (!((ServerSelectionMenu*)(Menu*)menuRegister->get(
                           "serverSelection"))
-                         ->hasServer(name->zText()->getText()))
+                        ->hasServer(name->zText()->getText()))
                 {
                     hide();
                     menuRegister->get("serverSelection")->show();
@@ -118,44 +118,44 @@ AddServerMenu::AddServerMenu(Bildschirm* zScreen)
                     address->zText()->setText("");
                     port->zText()->setText("");
                     sslPort->zText()->setText("");
-                    name->setAlphaFeldFarbe(0xFF3d3d3d);
-                    address->setAlphaFeldFarbe(0xFF3d3d3d);
-                    port->setAlphaFeldFarbe(0xFF3d3d3d);
-                    sslPort->setAlphaFeldFarbe(0xFF3d3d3d);
+                    name->setAlphaFieldColor(0xFF3d3d3d);
+                    address->setAlphaFieldColor(0xFF3d3d3d);
+                    port->setAlphaFieldColor(0xFF3d3d3d);
+                    sslPort->setAlphaFieldColor(0xFF3d3d3d);
                 }
                 else
-                    name->setAlphaFeldFarbe(0xFF3d0000);
+                    name->setAlphaFieldColor(0xFF3d0000);
             }
             else
             {
                 if (!name->zText()->getLength())
-                    name->setAlphaFeldFarbe(0xFF3d0000);
+                    name->setAlphaFieldColor(0xFF3d0000);
                 if (!address->zText()->getLength())
-                    address->setAlphaFeldFarbe(0xFF3d0000);
+                    address->setAlphaFieldColor(0xFF3d0000);
                 if (!port->zText()->getLength())
-                    port->setAlphaFeldFarbe(0xFF3d0000);
+                    port->setAlphaFieldColor(0xFF3d0000);
                 if (!sslPort->zText()->getLength())
-                    sslPort->setAlphaFeldFarbe(0xFF3d0000);
+                    sslPort->setAlphaFieldColor(0xFF3d0000);
             }
         }
         return 1;
     });
     elements.add(add);
 
-    abort = initKnopf(
-        center.x - 150, center.y + 50, 100, 20, Knopf::Style::Normal, "Abort");
-    abort->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    abort = initButton(
+        center.x - 150, center.y + 50, 100, 20, Button::Style::Normal, "Abort");
+    abort->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             hide();
             menuRegister->get("serverSelection")->show();
             name->zText()->setText("");
             address->zText()->setText("");
             port->zText()->setText("");
-            name->setAlphaFeldFarbe(0xFF3d3d3d);
-            address->setAlphaFeldFarbe(0xFF3d3d3d);
-            port->setAlphaFeldFarbe(0xFF3d3d3d);
-            sslPort->setAlphaFeldFarbe(0xFF3d3d3d);
+            name->setAlphaFieldColor(0xFF3d3d3d);
+            address->setAlphaFieldColor(0xFF3d3d3d);
+            port->setAlphaFieldColor(0xFF3d3d3d);
+            sslPort->setAlphaFieldColor(0xFF3d3d3d);
         }
         return 1;
     });

FactoryCraft/AddServerMenu.h

@@ -1,20 +1,20 @@
 #pragma once
 
-#include <Knopf.h>
-#include <TextFeld.h>
+#include <Button.h>
+#include <TextField.h>
 
 #include "Menu.h"
 
 class AddServerMenu : public Menu
 {
 private:
-    Framework::TextFeld* name;
-    Framework::TextFeld* address;
-    Framework::TextFeld* sslPort;
-    Framework::TextFeld* port;
-    Framework::Knopf* add;
-    Framework::Knopf* abort;
+    Framework::TextField* name;
+    Framework::TextField* address;
+    Framework::TextField* sslPort;
+    Framework::TextField* port;
+    Framework::Button* add;
+    Framework::Button* abort;
 
 public:
-    AddServerMenu(Framework::Bildschirm* zScreen);
+    AddServerMenu(Framework::Screen* zScreen);
 };

FactoryCraft/Block.cpp

@@ -1,7 +1,7 @@
 #include "Block.h"
 
 #include <Shader.h>
-#include <Textur.h>
+#include <Texture.h>
 
 #include "CustomDX11API.h"
 #include "Globals.h"
@@ -9,7 +9,7 @@
 Block::Block(const BlockType* zType,
     Framework::Vec3<int> pos,
     Model3DData* model,
-    Model3DTextur* texture,
+    Model3DTexture* texture,
     int maxHP,
     bool transparent,
     bool needRequestModelInfo,
@@ -33,7 +33,7 @@ Block::Block(const BlockType* zType,
     // Model3D::setAlpha(transparent);
     Model3D::setPosition(
         (Framework::Vec3<float>)pos + Framework::Vec3<float>{0.5f, 0.5f, 0.5f});
-    setModelDaten(model);
+    setModelData(model);
     setModelTextur(texture);
     memset(lightData, 0, 6 * 6);
     setSize(size);
@@ -89,7 +89,7 @@ void Block::api(char* message)
             ModelInfo* old = currentModelInfo;
             ByteArrayReader reader(message + 1, 10000, 0);
             currentModelInfo = new ModelInfo(&reader);
-            setModelDaten(currentModelInfo->getModel());
+            setModelData(currentModelInfo->getModel());
             setSize(currentModelInfo->getSize());
             setModelTextur(currentModelInfo->getTexture());
             Chunk* zChunk = World::INSTANCE->zChunk(

FactoryCraft/Block.h

@@ -36,7 +36,7 @@ public:
     Block(const BlockType* zType,
         Vec3<int> position,
         Model3DData* model,
-        Model3DTextur* texture,
+        Model3DTexture* texture,
         int maxHp,
         bool transparent,
         bool needRequestModelInfo,

FactoryCraft/Chat.cpp

@@ -1,45 +1,45 @@
 #include "Chat.h"
 
 #include <AsynchronCall.h>
-#include <DateiSystem.h>
+#include <FileSystem.h>
 
 #include "ChatMessage.h"
 #include "Game.h"
 #include "Globals.h"
 
 Chat::Chat()
-    : OptionsWindow([this]() { options->addStyle(Fenster::Style::Sichtbar); }),
+    : OptionsWindow([this]() { options->addStyle(Window::Style::Visible); }),
       optionsAdded(0)
 {
-    addStyle( Fenster::Style::LeftPositionFixed
-        | Fenster::Style::BottomPositionFixed);
-    removeStyle(Fenster::Style::Beweglich);
+    addStyle(
+        Window::Style::LeftPositionFixed | Window::Style::BottomPositionFixed);
+    removeStyle(Window::Style::Movable);
     setTitel("Chat");
-    setClosingMe([this](void* p, void* o, Framework::MausEreignis me) {
-        if (me.id == Framework::ME_RLinks)
+    setClosingMe([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == Framework::ME_RLeft)
         {
-            removeStyle(Fenster::Style::Sichtbar);
+            removeStyle(Window::Style::Visible);
             ((Game*)(Menu*)menuRegister->get("game"))->makeChatButtonVisible();
         }
         return 1;
     });
     setSize(500, 300);
     setPosition(5, uiFactory.initParam.bildschirm->getBackBufferSize().y - 305);
-    setKMin(200, 100);
+    setBodyMin(200, 100);
 
     options = new ChatOptions();
 
     history = new ChatHistory();
-    history->setSize(getInnenBreite(), getInnenHeight() - 20);
+    history->setSize(getInnerWidth(), getInnerHeight() - 20);
     addMember(history);
 
-    commandLine = uiFactory.createTextFeld(uiFactory.initParam);
+    commandLine = uiFactory.createTextField(uiFactory.initParam);
     commandLine->setText("");
-    commandLine->setSize(getInnenBreite() - 20, 20);
-    commandLine->setPosition(0, getInnenHeight() - 20);
-    commandLine->setStyle(Framework::TextFeld::Style::TextFeld);
-    commandLine->setTastaturEreignis(
-        [this](void* p, void* o, Framework::TastaturEreignis te) {
+    commandLine->setSize(getInnerWidth() - 20, 20);
+    commandLine->setPosition(0, getInnerHeight() - 20);
+    commandLine->setStyle(Framework::TextField::Style::TextField);
+    commandLine->setKeyboardEvent(
+        [this](void* p, void* o, Framework::KeyboardEvent te) {
             if (te.id == Framework::TE_Release
                 && te.virtualKey == Framework::T_Enter)
             {
@@ -57,23 +57,23 @@ Chat::Chat()
         });
     addMember(commandLine);
 
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    sendButton = uiFactory.createKnopf(uiFactory.initParam);
-    sendButton->setAlphaFeldFarbe(0x5F337AB7);
+    sendButton = uiFactory.createButton(uiFactory.initParam);
+    sendButton->setAlphaFieldColor(0x5F337AB7);
     sendButton->setToolTipText(
-        "Send", uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
+        "Send", uiFactory.initParam.bildschirm, uiFactory.initParam.font);
     sendButton->setSize(20, 20);
-    sendButton->setPosition(getInnenBreite() - 20, getInnenHeight() - 20);
-    sendButton->addStyle(Framework::Knopf::Style::HBild
-                         | Framework::Knopf::Style::HAlpha
-                         | Framework::Knopf::Style::Hintergrund);
-    sendButton->setHintergrundBildZ(iconsDat.laden(0, new Text("send.png")));
-    sendButton->setMausEreignis(
-        [this](void* p, void* o, Framework::MausEreignis me) {
-            if (me.id == ME_RLinks)
+    sendButton->setPosition(getInnerWidth() - 20, getInnerHeight() - 20);
+    sendButton->addStyle(Framework::Button::Style::BImage
+                         | Framework::Button::Style::BAlpha
+                         | Framework::Button::Style::Background);
+    sendButton->setBackgroundImageZ(iconsDat.load(0, new Text("send.png")));
+    sendButton->setMouseEvent(
+        [this](void* p, void* o, Framework::MouseEvent me) {
+            if (me.id == ME_RLeft)
             {
                 if (commandLine->zText()->getLength() > 0)
                 {
@@ -111,16 +111,16 @@ bool Chat::tick(double time)
     {
         optionsAdded = 1;
         uiFactory.initParam.bildschirm->addMember(
-            dynamic_cast<Zeichnung*>(options->getThis()));
+            dynamic_cast<Drawable*>(options->getThis()));
     }
     return OptionsWindow::tick(time);
 }
 
-void Chat::render(Framework::Bild& rObj)
+void Chat::render(Framework::Image& rObj)
 {
-    history->setSize(getInnenBreite(), getInnenHeight() - 20);
-    commandLine->setSize(getInnenBreite() - 20, 20);
-    commandLine->setPosition(0, getInnenHeight() - 20);
-    sendButton->setPosition(getInnenBreite() - 20, getInnenHeight() - 20);
+    history->setSize(getInnerWidth(), getInnerHeight() - 20);
+    commandLine->setSize(getInnerWidth() - 20, 20);
+    commandLine->setPosition(0, getInnerHeight() - 20);
+    sendButton->setPosition(getInnerWidth() - 20, getInnerHeight() - 20);
     OptionsWindow::render(rObj);
 }

FactoryCraft/Chat.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "OptionsWindow.h"
-#include <TextFeld.h>
-#include <Knopf.h>
+#include <TextField.h>
+#include <Button.h>
 
 #include "ChatHistory.h"
 #include "ChatOptions.h"
@@ -11,8 +11,8 @@ class Chat : public OptionsWindow
 {
 private:
     ChatHistory* history;
-    Framework::TextFeld* commandLine;
-    Framework::Knopf* sendButton;
+    Framework::TextField* commandLine;
+    Framework::Button* sendButton;
     ChatOptions* options;
     bool optionsAdded;
     
@@ -23,5 +23,5 @@ public:
     void addMessage(char* data);
     void initOptions(char* data);
     bool tick(double time) override;
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };

FactoryCraft/ChatHistory.cpp

@@ -1,14 +1,14 @@
 #include "ChatHistory.h"
 
-#include <Bild.h>
+#include <Image.h>
 #include <Scroll.h>
 
 ChatHistory::ChatHistory()
-    : Framework::ZeichnungHintergrund()
+    : Framework::DrawableBackground()
 {
-    setStyle(Style::Sichtbar | Style::Erlaubt | Style::VScroll);
-    setVertikalScrollPos(0);
-    setMausEreignis(Framework::_ret1ME);
+    setStyle(Style::Visible | Style::Allowed | Style::VScroll);
+    setVerticalScrollPos(0);
+    setMouseEvent(Framework::_ret1ME);
 }
 
 void ChatHistory::addMessage(ChatMessage* message)
@@ -17,9 +17,9 @@ void ChatHistory::addMessage(ChatMessage* message)
     scrollToBottom = 1;
 }
 
-void ChatHistory::render(Framework::Bild& rObj)
+void ChatHistory::render(Framework::Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(innenPosition, innenSize)) return;
     rObj.addScrollOffset(
         horizontalScrollBar ? horizontalScrollBar->getScroll() : 0,
@@ -42,8 +42,8 @@ bool ChatHistory::tick(double tickVal)
     vertikalScrollBar->update(y, innenSize.y);
     if (scrollToBottom)
     {
-        setVertikalScrollPos(y);
+        setVerticalScrollPos(y);
         scrollToBottom = 0;
     }
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }

FactoryCraft/ChatHistory.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <Zeichnung.h>
+#include <Drawing.h>
 #include <Array.h>
 
 #include "ChatMessage.h"
 
-class ChatHistory : public Framework::ZeichnungHintergrund
+class ChatHistory : public Framework::DrawableBackground
 {
 private:
     Framework::RCArray<ChatMessage> messages;
@@ -15,6 +15,6 @@ public:
     ChatHistory();
 
     void addMessage(ChatMessage* message);
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
     bool tick(double tickVal) override;
 };

FactoryCraft/ChatMessage.cpp

@@ -1,15 +1,17 @@
 #include "ChatMessage.h"
+
 #include "Globals.h"
 
 ChatMessage::ChatMessage(char* data)
-    : TextFeld(),
+    : TextField(),
       lastWidth(0)
 {
-    setStyle(Style::VCenter | Style::Sichtbar | Style::Mehrzeilig | Style::AutoLineBreak);
-    setSchriftZ(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    setSchriftSize(12);
+    setStyle(Style::VCenter | Style::Visible | Style::Multiline
+             | Style::AutoLineBreak);
+    setFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    setFontSize(12);
     setAutoLineBreakSpacing("    ");
-    
+
     __int64 time = *(__int64*)data;
     short mLen = *(short*)(data + 8);
     char* message = new char[mLen + 1];
@@ -22,33 +24,33 @@ ChatMessage::ChatMessage(char* data)
     Framework::Text channelT = channel;
     delete[] channel;
 
-    Zeit converter(time);
-    Text* timeT = converter.getZeit("d.m.y h:i:s");
-    
-    setSchriftFarbe(0xFFFFFFFF);
-    if (channelT.istGleich("system:INFO"))
+    Time converter(time);
+    Text* timeT = converter.getTime("d.m.y h:i:s");
+
+    setFontColor(0xFFFFFFFF);
+    if (channelT.isEqual("system:INFO"))
     {
-        setSchriftFarbe(0xFFA0A0A0);
+        setFontColor(0xFFA0A0A0);
         channelT = "[INFO]";
     }
-    else if (channelT.istGleich("system:WARNING"))
+    else if (channelT.isEqual("system:WARNING"))
     {
-        setSchriftFarbe(0xFFFF7700);
+        setFontColor(0xFFFF7700);
         channelT = "[WARNING]";
     }
-    else if (channelT.istGleich("system:ERROR"))
+    else if (channelT.isEqual("system:ERROR"))
     {
-        setSchriftFarbe(0xFFFF0000);
+        setFontColor(0xFFFF0000);
         channelT = "[ERROR]";
     }
-    else if (channelT.hatAt(0, "player:"))
+    else if (channelT.hasAt(0, "player:"))
     {
         Text* tmp = channelT.getTeilText(7);
         channelT = *tmp;
         tmp->release();
     }
     Text tmp = *timeT + " " + channelT + " " + message;
-    tmp.ersetzen("\n", "\n    ");
+    tmp.replace("\n", "\n    ");
     setText(tmp);
     timeT->release();
     delete[] message;
@@ -56,10 +58,10 @@ ChatMessage::ChatMessage(char* data)
 
 bool ChatMessage::tick(double tickVal)
 {
-    if (getBreite() != lastWidth)
+    if (getWidth() != lastWidth)
     {
-        lastWidth = getBreite();
+        lastWidth = getWidth();
         setHeight(getNeededHeight());
     }
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }

FactoryCraft/ChatMessage.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <Text.h>
-#include <TextFeld.h>
+#include <TextField.h>
 
-class ChatMessage : public Framework::TextFeld
+class ChatMessage : public Framework::TextField
 {
 private:
     Framework::Text message;

FactoryCraft/ChatOptions.cpp

@@ -1,67 +1,64 @@
 #include "ChatOptions.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 
 ChatOptions::ChatOptions()
-    : Fenster()
+    : Window()
 {
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
-    
-    setStyle(
-        Fenster::Style::Erlaubt | Fenster::Style::Rahmen
-        | Fenster::Style::BodyHAlpha | Fenster::Style::Titel
-        | Fenster::Style::TitelHAlpha | Fenster::Style::Closable
-        | Fenster::Style::ClosingHAlpha | Fenster::Style::ClosingKlickBuffer
-        | Fenster::Style::TitelHintergrund | Fenster::Style::BodyHintergrund
-        | Fenster::Style::ClosingHintergrund | Fenster::Style::MEIgnoreInside
-        | Fenster::Style::Beweglich | Style::ClosingHBild
-        | Style::ClosingBuffer);
-    removeStyle(Fenster::Style::Sichtbar);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
+
+    setStyle(Window::Style::Allowed | Window::Style::Border
+             | Window::Style::BodyBAlpha | Window::Style::Title
+             | Window::Style::TitleBAlpha | Window::Style::Closable
+             | Window::Style::ClosingBAlpha | Window::Style::ClosingBuffer
+             | Window::Style::TitleBackground | Window::Style::BodyBackground
+             | Window::Style::ClosingBackground | Window::Style::MEIgnoreInside
+             | Window::Style::Movable | Style::ClosingBImage
+             | Style::ClosingBuffer);
+    removeStyle(Window::Style::Visible);
     setTitel("Chat options");
-    setClosingMe([this](void* p, void* o, Framework::MausEreignis me) {
-        if (me.id == Framework::ME_RLinks)
+    setClosingMe([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == Framework::ME_RLeft)
         {
-            removeStyle(Fenster::Style::Sichtbar);
+            removeStyle(Window::Style::Visible);
         }
         return 1;
     });
     setSize(262, 367);
     setPosition(5, uiFactory.initParam.bildschirm->getBackBufferSize().y - 680);
-    setMausEreignis(Framework::_ret1ME);
-    setTastaturEreignis(Framework::_ret1TE);
-    setRBreite(1);
-    setRFarbe(0xFF52525E);
-    setKBgFarbe(0xA0000000);
-    setTBgFarbe(0xA0000000);
-    setSBgFarbe(0xA0000000);
-    setTSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    zTTextFeld()->setSize(0, 20);
-    zTTextFeld()->addStyle(TextFeld::Style::Center);
-    setSAfStrength(10);
-    setSAfFarbe(0x5F9C0A0A);
-    setSBgBildZ(iconsDat.laden(0, new Text("close.png")));
-    setSKAfFarbe(0xFF9C0A0A);
-    setSKAfStrength(10);
+    setMouseEvent(Framework::_ret1ME);
+    setKeyboardEvent(Framework::_ret1TE);
+    setBorderWidth(1);
+    setBorderColor(0xFF52525E);
+    setBodyBgColor(0xA0000000);
+    setTBgColor(0xA0000000);
+    setCloseBgColor(0xA0000000);
+    setTFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    zTTextField()->setSize(0, 20);
+    zTTextField()->addStyle(TextField::Style::Center);
+    setCloseAfStrength(10);
+    setCloseAfColor(0x5F9C0A0A);
+    setCloseBgImageZ(iconsDat.load(0, new Text("close.png")));
+    setCloseClickAfColor(0xFF9C0A0A);
+    setCloseAfStrength(10);
 
-    infoChannel = initKontrollKnopf(5,
+    infoChannel = initCheckBox(5,
         5,
         250,
         20,
-        Framework::KontrollKnopf::Style::Normal
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        Framework::CheckBox::Style::Normal
+            & ~Framework::CheckBox::Style::Border,
         "Show info messages");
-    infoChannel->setNMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    infoChannel->setPostMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             char msg[13];
-            msg[0]
-                = infoChannel->hatStyle(KontrollKnopf::Style::Selected) ? 1 : 2;
+            msg[0] = infoChannel->hasStyle(CheckBox::Style::Selected) ? 1 : 2;
             msg[1] = 11;
             memcpy(msg + 2, "system:INFO", 11);
             World::INSTANCE->zClient()->chatAPIRequest(msg, 13);
@@ -69,20 +66,19 @@ ChatOptions::ChatOptions()
         return 1;
     });
     addMember(infoChannel);
-    warningChannel = initKontrollKnopf(5,
+    warningChannel = initCheckBox(5,
         30,
         250,
         20,
-        Framework::KontrollKnopf::Style::Normal
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        Framework::CheckBox::Style::Normal
+            & ~Framework::CheckBox::Style::Border,
         "Show warning messages");
-    warningChannel->setNMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    warningChannel->setPostMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             char msg[16];
-            msg[0] = warningChannel->hatStyle(KontrollKnopf::Style::Selected)
-                       ? 1
-                       : 2;
+            msg[0]
+                = warningChannel->hasStyle(CheckBox::Style::Selected) ? 1 : 2;
             msg[1] = 14;
             memcpy(msg + 2, "system:WARNING", 14);
             World::INSTANCE->zClient()->chatAPIRequest(msg, 16);
@@ -90,19 +86,18 @@ ChatOptions::ChatOptions()
         return 1;
     });
     addMember(warningChannel);
-    errorChannel = initKontrollKnopf(5,
+    errorChannel = initCheckBox(5,
         55,
         250,
         20,
-        Framework::KontrollKnopf::Style::Normal
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        Framework::CheckBox::Style::Normal
+            & ~Framework::CheckBox::Style::Border,
         "Show error messages");
-    errorChannel->setNMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    errorChannel->setPostMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             char msg[14];
-            msg[0] = errorChannel->hatStyle(KontrollKnopf::Style::Selected) ? 1
-                                                                            : 2;
+            msg[0] = errorChannel->hasStyle(CheckBox::Style::Selected) ? 1 : 2;
             msg[1] = 12;
             memcpy(msg + 2, "system:ERROR", 12);
             World::INSTANCE->zClient()->chatAPIRequest(msg, 14);
@@ -110,46 +105,46 @@ ChatOptions::ChatOptions()
         return 1;
     });
     addMember(errorChannel);
-    TextFeld* blackListLabel = initTextFeld(5,
+    TextField* blackListLabel = initTextField(5,
         90,
         250,
         20,
-        Framework::TextFeld::Style::Text | Framework::TextFeld::Style::VCenter,
+        Framework::TextField::Style::Text
+            | Framework::TextField::Style::VCenter,
         "Ignored players:");
     addMember(blackListLabel);
-    
-    plus = iconsDat.laden(0, new Text("plus.png"));
-    trash = iconsDat.laden(0, new Text("trash.png"));
 
-    playerName = initTextFeld(
-        5, 115, 225, 20, Framework::TextFeld::Style::TextFeld, "");
-    playerName->setTastaturEreignis(
-        [this](void* o, void* p, TastaturEreignis te) {
-            if (te.id == TE_Release && te.virtualKey == T_Enter)
+    plus = iconsDat.load(0, new Text("plus.png"));
+    trash = iconsDat.load(0, new Text("trash.png"));
+
+    playerName = initTextField(
+        5, 115, 225, 20, Framework::TextField::Style::TextField, "");
+    playerName->setKeyboardEvent([this](void* o, void* p, KeyboardEvent te) {
+        if (te.id == TE_Release && te.virtualKey == T_Enter)
+        {
+            if (playerName->zText()->getLength())
             {
-                if (playerName->zText()->getLength())
-                {
-                    addIgnoredPlayer(playerName->zText()->getText(), 1);
-                    playerName->setText("");
-                }
+                addIgnoredPlayer(playerName->zText()->getText(), 1);
+                playerName->setText("");
             }
-            return 1;
-        });
+        }
+        return 1;
+    });
     addMember(playerName);
-    addButton = initKnopf(235,
+    addButton = initButton(235,
         115,
         20,
         20,
-        Framework::Knopf::Style::HBild | Framework::Knopf::Style::HAlpha
-            | Framework::Knopf::Style::Hintergrund,
+        Framework::Button::Style::BImage | Framework::Button::Style::BAlpha
+            | Framework::Button::Style::Background,
         "");
-    addButton->setAlphaFeldFarbe(0x5F337AB7);
+    addButton->setAlphaFieldColor(0x5F337AB7);
     addButton->setToolTipText("Add player to list of ignored players",
         uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
-    addButton->setHintergrundBildZ(dynamic_cast<Bild*>(plus->getThis()));
-    addButton->setMausEreignis([this](void* o, void* p, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        uiFactory.initParam.font);
+    addButton->setBackgroundImageZ(dynamic_cast<Image*>(plus->getThis()));
+    addButton->setMouseEvent([this](void* o, void* p, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             if (playerName->zText()->getLength())
             {
@@ -160,12 +155,12 @@ ChatOptions::ChatOptions()
         return 1;
     });
     addMember(addButton);
-    blackList = initObjTabelle(5,
+    blackList = initObjTable(5,
         140,
         250,
         200,
-        Framework::ObjTabelle::Style::normal
-            | Framework::ObjTabelle::Style::VScroll,
+        Framework::ObjTable::Style::normal
+            | Framework::ObjTable::Style::VScroll,
         {
             {"Player", 212, 212, 212},
             {"Remove", 20,  20,  20 }
@@ -182,9 +177,9 @@ ChatOptions::~ChatOptions()
 
 void ChatOptions::init(char* data)
 {
-    infoChannel->removeStyle(KontrollKnopf::Style::Selected);
-    warningChannel->removeStyle(KontrollKnopf::Style::Selected);
-    errorChannel->removeStyle(KontrollKnopf::Style::Selected);
+    infoChannel->removeStyle(CheckBox::Style::Selected);
+    warningChannel->removeStyle(CheckBox::Style::Selected);
+    errorChannel->removeStyle(CheckBox::Style::Selected);
     int len = *(int*)data;
     data += 4;
     for (int i = 0; i < len; i++)
@@ -193,21 +188,21 @@ void ChatOptions::init(char* data)
         data += len;
         if (len == 11)
         {
-            infoChannel->addStyle(KontrollKnopf::Style::Selected);
+            infoChannel->addStyle(CheckBox::Style::Selected);
         }
         if (len == 12)
         {
-            errorChannel->addStyle(KontrollKnopf::Style::Selected);
+            errorChannel->addStyle(CheckBox::Style::Selected);
         }
         if (len == 14)
         {
-            warningChannel->addStyle(KontrollKnopf::Style::Selected);
+            warningChannel->addStyle(CheckBox::Style::Selected);
         }
     }
     uiFactory.initParam.bildschirm->postAction([this]() {
-        while (blackList->getZeilenAnzahl())
+        while (blackList->getRowCount())
         {
-            blackList->removeZeile(0);
+            blackList->removeRow(0);
         }
     });
     len = *(int*)data;
@@ -226,7 +221,7 @@ void ChatOptions::init(char* data)
 
 void ChatOptions::addIgnoredPlayer(Framework::Text playerName, bool msg)
 {
-    if (blackList->getZeilenNummer(playerName) >= 0) return;
+    if (blackList->getRowNumber(playerName) >= 0) return;
     if (msg)
     {
         char* msg = new char[2 + playerName.getLength()];
@@ -238,34 +233,34 @@ void ChatOptions::addIgnoredPlayer(Framework::Text playerName, bool msg)
         delete[] msg;
     }
     uiFactory.initParam.bildschirm->postAction([this, playerName]() {
-        if (blackList->getZeilenNummer(playerName) >= 0) return;
-        blackList->addZeile(playerName);
-        blackList->setZeichnungZ("Player",
+        if (blackList->getRowNumber(playerName) >= 0) return;
+        blackList->addRow(playerName);
+        blackList->setDrawableZ("Player",
             playerName,
-            initTextFeld(0,
+            initTextField(0,
                 0,
                 0,
                 0,
-                TextFeld::Style::Text | TextFeld::Style::VCenter,
+                TextField::Style::Text | TextField::Style::VCenter,
                 playerName.getText()));
-        Knopf* removeButton = initKnopf(0,
+        Button* removeButton = initButton(0,
             0,
             0,
             0,
-            Framework::Knopf::Style::HBild | Framework::Knopf::Style::HAlpha
-                | Framework::Knopf::Style::Hintergrund,
+            Framework::Button::Style::BImage | Framework::Button::Style::BAlpha
+                | Framework::Button::Style::Background,
             "");
-        removeButton->removeStyle(Knopf::Style::Rahmen);
-        removeButton->setAlphaFeldFarbe(0x5F337AB7);
+        removeButton->removeStyle(Button::Style::Border);
+        removeButton->setAlphaFieldColor(0x5F337AB7);
         removeButton->setToolTipText(
             "Remove player from list of ignored players",
             uiFactory.initParam.bildschirm,
-            uiFactory.initParam.schrift);
-        removeButton->setHintergrundBildZ(
-            dynamic_cast<Bild*>(trash->getThis()));
-        removeButton->setMausEreignis(
-            [this, playerName](void* o, void* p, MausEreignis me) {
-                if (me.id == ME_RLinks)
+            uiFactory.initParam.font);
+        removeButton->setBackgroundImageZ(
+            dynamic_cast<Image*>(trash->getThis()));
+        removeButton->setMouseEvent(
+            [this, playerName](void* o, void* p, MouseEvent me) {
+                if (me.id == ME_RLeft)
                 {
                     uiFactory.initParam.bildschirm->postAction(
                         [this, playerName]() {
@@ -276,11 +271,11 @@ void ChatOptions::addIgnoredPlayer(Framework::Text playerName, bool msg)
                             World::INSTANCE->zClient()->chatAPIRequest(
                                 msg, 2 + playerName.getLength());
                             delete[] msg;
-                            blackList->removeZeile(playerName);
+                            blackList->removeRow(playerName);
                         });
                 }
                 return 1;
             });
-        blackList->setZeichnungZ("Remove", playerName, removeButton);
+        blackList->setDrawableZ("Remove", playerName, removeButton);
     });
 }

FactoryCraft/ChatOptions.h

@@ -1,23 +1,23 @@
 #pragma once
 
-#include <Fenster.h>
-#include <Knopf.h>
-#include <Liste.h>
-#include <Tabelle.h>
+#include <Window.h>
+#include <Button.h>
+#include <List.h>
+#include <Table.h>
 
-class ChatOptions : public Framework::Fenster
+class ChatOptions : public Framework::Window
 {
 private:
-    Framework::KontrollKnopf* infoChannel;
-    Framework::KontrollKnopf* warningChannel;
-    Framework::KontrollKnopf* errorChannel;
+    Framework::CheckBox* infoChannel;
+    Framework::CheckBox* warningChannel;
+    Framework::CheckBox* errorChannel;
 
-    Framework::Bild* plus;
-    Framework::Bild* trash;
+    Framework::Image* plus;
+    Framework::Image* trash;
 
-    Framework::TextFeld* playerName;
-    Framework::Knopf* addButton;
-    Framework::ObjTabelle* blackList;
+    Framework::TextField* playerName;
+    Framework::Button* addButton;
+    Framework::ObjTable* blackList;
 
 public:
     ChatOptions();

FactoryCraft/Chunk.cpp

@@ -10,7 +10,7 @@
 #include "Globals.h"
 #include "TransparentChunkGroundModel.h"
 
-Chunk::Chunk(Framework::Punkt location)
+Chunk::Chunk(Framework::Point location)
     : ReferenceCounter(),
       location(location),
       isLoading(0),
@@ -33,7 +33,7 @@ Chunk::Chunk(Framework::Punkt location)
     chunkModel->setDiffusFactor(1.f);
     chunkModel->setSpecularFactor(0.f);
     chunkModel->setVertecies(0, 0);
-    ground->setModelDaten(chunkModel);
+    ground->setModelData(chunkModel);
     ground->setPosition(
         (float)location.x, (float)location.y, (float)WORLD_HEIGHT / 2.f);
     ground->tick(0);
@@ -52,7 +52,7 @@ Chunk::Chunk(Framework::Punkt location)
     chunkModel->setDiffusFactor(1.f);
     chunkModel->setSpecularFactor(0.f);
     chunkModel->setVertecies(0, 0);
-    transparentGround->setModelDaten(chunkModel);
+    transparentGround->setModelData(chunkModel);
     transparentGround->setPosition(
         (float)location.x, (float)location.y, (float)WORLD_HEIGHT / 2.f);
     transparentGround->tick(0);
@@ -72,7 +72,7 @@ Chunk::Chunk(Framework::Punkt location)
     chunkModel->setDiffusFactor(1.f);
     chunkModel->setSpecularFactor(0.f);
     chunkModel->setVertecies(0, 0);
-    fluids->setModelDaten(chunkModel);
+    fluids->setModelData(chunkModel);
     fluids->setPosition(
         (float)location.x, (float)location.y, (float)WORLD_HEIGHT / 2.f);
     fluids->tick(0);
@@ -80,7 +80,7 @@ Chunk::Chunk(Framework::Punkt location)
     modelBuilders.add(fluidModel);
 }
 
-Chunk::Chunk(Framework::Punkt location, Framework::StreamReader* zReader)
+Chunk::Chunk(Framework::Point location, Framework::StreamReader* zReader)
     : Chunk(location)
 {
     load(zReader);
@@ -145,27 +145,27 @@ void Chunk::load(Framework::StreamReader* zReader)
     isLoading = 1;
     Framework::Vec3<int> pos = {0, 0, 0};
     unsigned short id;
-    zReader->lese((char*)&id, 2);
+    zReader->read((char*)&id, 2);
     int count = 0;
     while (id)
     {
         int index;
-        zReader->lese((char*)&index, 4);
+        zReader->read((char*)&index, 4);
         char state = 0;
-        zReader->lese(&state, 1);
+        zReader->read(&state, 1);
         char flowOptions = 0;
         char distanceToSource = 0;
         if ((state | 1) == state)
         {
-            zReader->lese(&flowOptions, 1);
-            zReader->lese(&distanceToSource, 1);
+            zReader->read(&flowOptions, 1);
+            zReader->read(&distanceToSource, 1);
         }
         bool passable = 0;
         float speedModifier = 1.f;
         if ((state | 2) == state)
         {
             passable = 1;
-            zReader->lese((char*)&speedModifier, 4);
+            zReader->read((char*)&speedModifier, 4);
         }
         pos = Vec3<int>((index / WORLD_HEIGHT) / CHUNK_SIZE,
             (index / WORLD_HEIGHT) % CHUNK_SIZE,
@@ -185,9 +185,9 @@ void Chunk::load(Framework::StreamReader* zReader)
             vcs.lock();
             if (b->isVisible())
             {
-                if (!blockTypes[id]->getModelInfo().getModelName().istGleich(
+                if (!blockTypes[id]->getModelInfo().getModelName().isEqual(
                         "cube")
-                    && !blockTypes[id]->getModelInfo().getModelName().istGleich(
+                    && !blockTypes[id]->getModelInfo().getModelName().isEqual(
                         "grass"))
                 {
                     b->tick(0);
@@ -197,12 +197,12 @@ void Chunk::load(Framework::StreamReader* zReader)
             count++;
             vcs.unlock();
         }
-        zReader->lese((char*)&id, 2);
+        zReader->read((char*)&id, 2);
     }
     std::cout << "Loaded " << count << " blocks\n";
     int index = 0;
     // light
-    zReader->lese((char*)&index, 4);
+    zReader->read((char*)&index, 4);
     char lightData[6];
     while (index >= -1)
     {
@@ -211,10 +211,10 @@ void Chunk::load(Framework::StreamReader* zReader)
             int x = 0;
             int y = 0;
             int z = 0;
-            zReader->lese((char*)&x, 4);
-            zReader->lese((char*)&y, 4);
-            zReader->lese((char*)&z, 4);
-            zReader->lese(lightData, 6);
+            zReader->read((char*)&x, 4);
+            zReader->read((char*)&y, 4);
+            zReader->read((char*)&z, 4);
+            zReader->read(lightData, 6);
             if (x == -1)
             {
                 int cacheIndex = y * WORLD_HEIGHT + z;
@@ -256,7 +256,7 @@ void Chunk::load(Framework::StreamReader* zReader)
         }
         else
         {
-            zReader->lese(lightData, 6);
+            zReader->read(lightData, 6);
             Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
                 (index / WORLD_HEIGHT) % CHUNK_SIZE,
                 index % WORLD_HEIGHT);
@@ -315,7 +315,7 @@ void Chunk::load(Framework::StreamReader* zReader)
                 }
             }
         }
-        zReader->lese((char*)&index, 4);
+        zReader->read((char*)&index, 4);
     }
     isLoading = 0;
 }
@@ -423,7 +423,7 @@ void Chunk::destroy()
     {
         Model3DData* chunkModel = builder->zModel()->zModelData();
         // remove old model
-        while (chunkModel->getPolygonAnzahl() > 0)
+        while (chunkModel->getPolygonCount() > 0)
         {
             chunkModel->removePolygon(0);
         }
@@ -625,7 +625,7 @@ void Chunk::blockVisibilityChanged(Block* zB)
     vcs.unlock();
 }
 
-Framework::Punkt Chunk::getCenter() const
+Framework::Point Chunk::getCenter() const
 {
     return location;
 }

FactoryCraft/Chunk.h

@@ -4,7 +4,7 @@
 #include <Critical.h>
 #include <Model3D.h>
 #include <Model3DCollection.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Reader.h>
 
 #include "Area.h"
@@ -26,7 +26,7 @@ public:
 };
 
 private:
-    Framework::Punkt location;
+    Framework::Point location;
     // TODO: use native array for bedder performance?
     Block** blocks;
     Framework::Array<Block*> visibleBlocks;
@@ -46,8 +46,8 @@ private:
     void updateLight(ChunkModelBuilder *builder);
 
 public:
-    Chunk(Framework::Punkt location);
-    Chunk(Framework::Punkt location, Framework::StreamReader* zReader);
+    Chunk(Framework::Point location);
+    Chunk(Framework::Point location, Framework::StreamReader* zReader);
     ~Chunk();
 
     void renderSolid(std::function<void(Model3D*)> f);
@@ -60,7 +60,7 @@ public:
     void setBlock(Block* block);
     void removeBlock(Block* zBlock);
     void blockVisibilityChanged(Block* zB);
-    Framework::Punkt getCenter() const;
+    Framework::Point getCenter() const;
     Framework::Vec3<int> getMin() const;
     Framework::Vec3<int> getMax() const;
     void setModelChanged(int modelType);

FactoryCraft/ChunkFluidModel.cpp

@@ -115,7 +115,7 @@ void ChunkFluidModel::buildModel()
 {
     Model3DData* chunkModel = target->zModelData();
     // remove old model
-    while (chunkModel->getPolygonAnzahl() > 0)
+    while (chunkModel->getPolygonCount() > 0)
     {
         chunkModel->removePolygon(0);
     }
@@ -237,7 +237,7 @@ void ChunkFluidModel::buildModel()
             }
         }
     }
-    Model3DTextur* textur = new Model3DTextur();
+    Model3DTexture* texture = new Model3DTexture();
     int pi = 0;
     for (GroundModelPart* part : groundPartArray)
     {
@@ -245,21 +245,21 @@ void ChunkFluidModel::buildModel()
         polygon->indexAnz = part->indexCount;
         polygon->indexList = part->indexList;
         target->zModelData()->addPolygon(polygon);
-        textur->setPolygonTextur(pi,
-            uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTextur(
+        texture->setPolygonTexture(pi,
+            uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTexture(
                 part->name));
         pi++;
         delete part;
     }
     target->zModelData()->setVertecies(groundVerticies, groundVertexCount);
-    target->setModelTextur(textur);
+    target->setModelTextur(texture);
     target->setVertexLightBuffer(lightBuffer, groundVertexCount);
 }
 
 bool ChunkFluidModel::updateLightning()
 {
     __int64* lightBuffer = target->zLightBuffer();
-    int oldVertexCount = target->getVertexAnzahl();
+    int oldVertexCount = target->getVertexCount();
     int groundVertexCount = 0;
     for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT; i++)
     {

FactoryCraft/ChunkGroundModel.cpp

@@ -104,7 +104,7 @@ bool ChunkGroundModel::isPartOfGroundModel(
             || !blocks()[naighborIndex]
                 ->getCurrentModelInfo()
                 .getModelName()
-                .istGleich("cube"))
+                .isEqual("cube"))
         {
             needed = 1;
         }
@@ -116,7 +116,7 @@ void ChunkGroundModel::buildModel()
 {
     Model3DData* chunkModel = target->zModelData();
     // remove old model
-    while (chunkModel->getPolygonAnzahl() > 0)
+    while (chunkModel->getPolygonCount() > 0)
     {
         chunkModel->removePolygon(0);
     }
@@ -217,7 +217,7 @@ void ChunkGroundModel::buildModel()
             }
         }
     }
-    Model3DTextur* textur = new Model3DTextur();
+    Model3DTexture* texture = new Model3DTexture();
     int pi = 0;
     for (GroundModelPart* part : groundPartArray)
     {
@@ -225,14 +225,14 @@ void ChunkGroundModel::buildModel()
         polygon->indexAnz = part->indexCount;
         polygon->indexList = part->indexList;
         target->zModelData()->addPolygon(polygon);
-        textur->setPolygonTextur(pi,
-            uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTextur(
+        texture->setPolygonTexture(pi,
+            uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTexture(
                 part->name));
         pi++;
         delete part;
     }
     target->zModelData()->setVertecies(groundVerticies, groundVertexCount);
-    target->setModelTextur(textur);
+    target->setModelTextur(texture);
     target->setVertexLightBuffer(lightBuffer, groundVertexCount);
 }
 
@@ -284,5 +284,5 @@ bool ChunkGroundModel::isTransparent() const
 
 bool ChunkGroundModel::isPartOfModel(Block* zBlock) const
 {
-    return zBlock->getCurrentModelInfo().getModelName().istGleich("cube");
+    return zBlock->getCurrentModelInfo().getModelName().isEqual("cube");
 }

FactoryCraft/ChunkMap.cpp

@@ -10,23 +10,23 @@ ChunkMap::ChunkMap(Framework::StreamReader* zReader)
     memset(pixels, 0, sizeof(MapPixel) * CHUNK_SIZE * CHUNK_SIZE);
     heightMap = new unsigned char[CHUNK_SIZE * CHUNK_SIZE];
     memset(heightMap, 0, CHUNK_SIZE * CHUNK_SIZE);
-    zReader->lese((char*)&chunkCenter.x, 4);
-    zReader->lese((char*)&chunkCenter.y, 4);
+    zReader->read((char*)&chunkCenter.x, 4);
+    zReader->read((char*)&chunkCenter.y, 4);
     for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE; i++)
     {
-        zReader->lese((char*)&pixels[i].len, 1);
+        zReader->read((char*)&pixels[i].len, 1);
         if (pixels[i].len > 0)
         {
             pixels[i].blocks = new MapBlock[pixels[i].len];
-            zReader->lese(
+            zReader->read(
                 (char*)pixels[i].blocks, (int)sizeof(MapBlock) * pixels[i].len);
         }
     }
-    rendered.neuBild(16, 16, 0xA0000000);
+    rendered.newImage(16, 16, 0xA0000000);
     setMaxHeight(255);
 }
 
-ChunkMap::ChunkMap(Framework::Punkt center)
+ChunkMap::ChunkMap(Framework::Point center)
     : ReferenceCounter(),
       chunkCenter(center),
       maxHeight(0)
@@ -35,7 +35,7 @@ ChunkMap::ChunkMap(Framework::Punkt center)
     memset(pixels, 0, sizeof(MapPixel) * CHUNK_SIZE * CHUNK_SIZE);
     heightMap = new unsigned char[CHUNK_SIZE * CHUNK_SIZE];
     memset(heightMap, 0, CHUNK_SIZE * CHUNK_SIZE);
-    rendered.neuBild(16, 16, 0xA0000000);
+    rendered.newImage(16, 16, 0xA0000000);
     setMaxHeight(255);
 }
 
@@ -79,7 +79,7 @@ void ChunkMap::setMaxHeight(unsigned char maxHeight)
     }
 }
 
-const Framework::Bild& ChunkMap::getRenderedImage() const
+const Framework::Image& ChunkMap::getRenderedImage() const
 {
     return rendered;
 }
@@ -89,7 +89,7 @@ unsigned char* ChunkMap::getHeightMap() const
     return heightMap;
 }
 
-Framework::Punkt ChunkMap::getChunkCenter() const
+Framework::Point ChunkMap::getChunkCenter() const
 {
     return chunkCenter;
 }

FactoryCraft/ChunkMap.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Bild.h>
+#include <Image.h>
 
 #pragma pack(push, 1)
 
@@ -26,18 +26,18 @@ class ChunkMap : public Framework::ReferenceCounter
 private:
     MapPixel* pixels;
     unsigned char* heightMap;
-    Framework::Punkt chunkCenter;
-    Framework::Bild rendered;
+    Framework::Point chunkCenter;
+    Framework::Image rendered;
     unsigned char maxHeight;
     
 public:
     ChunkMap(Framework::StreamReader* zReader);
-    ChunkMap(Framework::Punkt center);
+    ChunkMap(Framework::Point center);
     ~ChunkMap();
     
     void setMaxHeight(unsigned char maxHeight);
     
-    const Framework::Bild &getRenderedImage() const;
+    const Framework::Image &getRenderedImage() const;
     unsigned char* getHeightMap() const;
-    Framework::Punkt getChunkCenter() const;
+    Framework::Point getChunkCenter() const;
 };

FactoryCraft/ChunkModelBuilder.cpp

@@ -33,7 +33,7 @@ void ChunkModelBuilder::setBlockPartOfModel(Block* zBlock, bool partOfModel)
     }
 }
 
-Framework::Punkt ChunkModelBuilder::chunkCenter()
+Framework::Point ChunkModelBuilder::chunkCenter()
 {
     return zChunk->location;
 }

FactoryCraft/ChunkModelBuilder.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <ReferenceCounter.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Text.h>
 
 class Block;
@@ -26,7 +26,7 @@ protected:
     FactoryCraftModel* target;
     Block** blocks();
     void setBlockPartOfModel(Block* zBlock, bool partOfModel);
-    Framework::Punkt chunkCenter();
+    Framework::Point chunkCenter();
 
 public:
     ChunkModelBuilder(FactoryCraftModel* target, Chunk* zChunk, int type);

FactoryCraft/CraftingGrid.cpp

@@ -1,6 +1,6 @@
 #include "CraftingGrid.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 #include <XML.h>
 
 #include "DragController.h"
@@ -15,14 +15,14 @@ CraftingGridElement::CraftingGridElement()
     : UIMLElement()
 {}
 
-//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig ist
+//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig ist
 bool CraftingGridElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("craftingGrid");
+    return element.getName().isEqual("craftingGrid");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* CraftingGridElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* CraftingGridElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     Text targetValue = element.getAttributeValue("target");
@@ -37,15 +37,15 @@ Framework::Zeichnung* CraftingGridElement::parseElement(
 }
 
 bool CraftingGridElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void CraftingGridElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -60,7 +60,7 @@ CraftingGridView::CraftingGridView(Text id,
     int numOutputSlots,
     int* address,
     int addressLength)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       NetworkAPIProcessor(),
       rowSize(rowSize),
       colSize(colSize),
@@ -75,12 +75,12 @@ CraftingGridView::CraftingGridView(Text id,
       currentTooltipSlot(-1),
       requestetTooltipSlot(-1)
 {
-    craft = uiFactory.createKnopf(uiFactory.initParam);
+    craft = uiFactory.createButton(uiFactory.initParam);
     craft->setPosition(rowSize * 60, 0);
     craft->setSize(40, 20);
     craft->setText("Craft");
-    craft->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    craft->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             char* msg = new char[2 + 4 * this->addressLength];
             msg[0] = 7; // request crafting
@@ -96,29 +96,28 @@ CraftingGridView::CraftingGridView(Text id,
         }
         return 1;
     });
-    recipies = uiFactory.createKnopf(uiFactory.initParam);
+    recipies = uiFactory.createButton(uiFactory.initParam);
     recipies->setPosition(rowSize * 60, colSize * 60 - 49);
     recipies->setSize(40, 40);
-    recipies->addStyle(
-        Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::Hintergrund);
-    recipies->removeStyle(Knopf::Style::Buffered);
-    recipies->setRahmenBreite(1);
-    Framework::LTDBDatei file;
-    file.setDatei(new Framework::Text("data/images/gui_icons.ltdb"));
-    file.leseDaten(0);
-    recipies->setHintergrundBildZ(file.laden(0, new Text("recipies.png")));
-    recipies->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    recipies->addStyle(Button::Style::BImage | Button::Style::BAlpha
+                       | Button::Style::Background);
+    recipies->removeStyle(Button::Style::Buffered);
+    recipies->setBorderWidth(1);
+    Framework::LTDBFile file;
+    file.setFile(new Framework::Text("data/images/gui_icons.ltdb"));
+    file.readData(0);
+    recipies->setBackgroundImageZ(file.load(0, new Text("recipies.png")));
+    recipies->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             ((Game*)(Menu*)menuRegister->get("game"))->showItemList();
         }
         return 1;
     });
-    recipies->setToolTipText("Recipies",
-        uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
-    setStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Erlaubt);
+    recipies->setToolTipText(
+        "Recipies", uiFactory.initParam.bildschirm, uiFactory.initParam.font);
+    setStyle(DrawableBackground::Style::Visible
+             | DrawableBackground::Style::Allowed);
     char* msg = new char[id.getLength() + 12 + 3 + 4];
     msg[0] = 0; // request inventory tooltip
     msg[1] = (char)id.getLength();
@@ -135,7 +134,7 @@ CraftingGridView::CraftingGridView(Text id,
         msg,
         id.getLength() + 12 + 3 + 4);
     delete[] msg;
-    setNeedToolTipEvent([this](Zeichnung* z, Punkt p) {
+    setNeedToolTipEvent([this](Drawable* z, Point p) {
         int slot = getSlotByLocalPos(p);
         if (currentTooltipSlot != slot && currentTooltipSlot != -1)
         {
@@ -196,7 +195,7 @@ CraftingGridView::~CraftingGridView()
     recipies->release();
 }
 
-int CraftingGridView::getSlotByLocalPos(Punkt pos)
+int CraftingGridView::getSlotByLocalPos(Point pos)
 {
     int x = 0;
     int y = 0;
@@ -253,7 +252,7 @@ void CraftingGridView::api(char* message)
                 }
                 slots->add(info);
             }
-            window->zBildschirm()->postAction([this, slots]() {
+            window->zScreen()->postAction([this, slots]() {
                 if (this->slots) this->slots->release();
                 this->slots = slots;
             });
@@ -264,7 +263,7 @@ void CraftingGridView::api(char* message)
             if (!slots) return;
             int id = *(int*)(message + 1);
             int count = *(int*)(message + 5);
-            for (int i = 0; i < slots->getEintragAnzahl(); i++)
+            for (int i = 0; i < slots->getEntryCount(); i++)
             {
                 if (slots->get(i).id == id)
                 {
@@ -292,7 +291,7 @@ void CraftingGridView::api(char* message)
         {
             if (!slots) return;
             int id = *(int*)(message + 1);
-            for (int i = 0; i < slots->getEintragAnzahl(); i++)
+            for (int i = 0; i < slots->getEntryCount(); i++)
             {
                 if (slots->get(i).id == id)
                 {
@@ -360,7 +359,7 @@ void CraftingGridView::api(char* message)
                 }
                 outputs->add(info);
             }
-            window->zBildschirm()->postAction([this, outputs]() {
+            window->zScreen()->postAction([this, outputs]() {
                 if (this->outputs) this->outputs->release();
                 this->outputs = outputs;
             });
@@ -371,12 +370,12 @@ void CraftingGridView::api(char* message)
 
 bool CraftingGridView::tick(double tickVal)
 {
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void CraftingGridView::render(Bild& rObj)
+void CraftingGridView::render(Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     int numRows = 1;
     if (slots)
@@ -395,19 +394,19 @@ void CraftingGridView::render(Bild& rObj)
                 y += 60;
                 x = 0;
                 rowCount = 0;
-                if (index < slots->getEintragAnzahl() - 1) numRows++;
+                if (index < slots->getEntryCount() - 1) numRows++;
             }
             index++;
         }
     }
     craft->render(rObj);
-    recipies->setStyle(Knopf::Style::Sichtbar,
+    recipies->setStyle(Button::Style::Visible,
         !((Game*)(Menu*)menuRegister->get("game"))->isItemListVisible());
     recipies->render(rObj);
     rObj.fillRegion(rowSize * 60, gr.y / 2 - 5, 25, 10, 0xFF52525E);
-    rObj.drawDreieck(Punkt(rowSize * 60 + 25, gr.y / 2 - 15),
-        Punkt(rowSize * 60 + 40, gr.y / 2),
-        Punkt(rowSize * 60 + 25, gr.y / 2 + 15),
+    rObj.drawTriangle(Point(rowSize * 60 + 25, gr.y / 2 - 15),
+        Point(rowSize * 60 + 40, gr.y / 2),
+        Point(rowSize * 60 + 25, gr.y / 2 + 15),
         0xFF52525E);
     if (outputs)
     {
@@ -430,14 +429,14 @@ void CraftingGridView::render(Bild& rObj)
     rObj.releaseDrawOptions();
 }
 
-void CraftingGridView::doMausEreignis(MausEreignis& me, bool userRet)
+void CraftingGridView::doMouseEvent(MouseEvent& me, bool userRet)
 {
     mausPos.x = me.originalX;
     mausPos.y = me.originalY;
     if (!slots) return;
-    if (me.id == ME_Bewegung)
+    if (me.id == ME_Move)
     {
-        if (getSlotByLocalPos(Punkt(me.mx, me.my)) != currentTooltipSlot)
+        if (getSlotByLocalPos(Point(me.mx, me.my)) != currentTooltipSlot)
         {
             if (currentTooltipSlot != -1)
             {
@@ -449,8 +448,8 @@ void CraftingGridView::doMausEreignis(MausEreignis& me, bool userRet)
             currentTooltipSlot = -1;
         }
     }
-    craft->doPublicMausEreignis(me);
-    recipies->doPublicMausEreignis(me);
+    craft->doPublicMouseEvent(me);
+    recipies->doPublicMouseEvent(me);
     DragController<InventoryDragSource, int>* controller
         = ((Game*)(Menu*)menuRegister->get("game"))->zInventoryDragController();
     int x = 0;
@@ -462,7 +461,7 @@ void CraftingGridView::doMausEreignis(MausEreignis& me, bool userRet)
     {
         if (me.mx >= x && me.mx < x + 50 && me.my >= y && me.my < y + 50)
         {
-            if (me.id == ME_RLinks)
+            if (me.id == ME_RLeft)
             {
                 if (!controller->getCurrentDragContainer()
                     && info.itemCount > 0)
@@ -538,7 +537,7 @@ void CraftingGridView::doMausEreignis(MausEreignis& me, bool userRet)
         }
         slot++;
     }
-    ZeichnungHintergrund::doMausEreignis(me, userRet);
+    DrawableBackground::doMouseEvent(me, userRet);
 }
 
 Framework::Either<int, Framework::VecN<int, 4>>

FactoryCraft/CraftingGrid.h

@@ -14,21 +14,21 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class CraftingGridView : public Framework::ZeichnungHintergrund,
+class CraftingGridView : public Framework::DrawableBackground,
                          public NetworkAPIProcessor,
                          public InventoryDragSource
 {
@@ -42,14 +42,14 @@ private:
     Framework::Array<SlotInfo>* slots;
     Framework::Array<SlotInfo>* outputs;
     Framework::Text id;
-    Framework::Punkt mausPos;
+    Framework::Point mausPos;
     int dragStartId;
     int dragStopId;
-    Framework::Knopf* craft;
-    Framework::Knopf* recipies;
+    Framework::Button* craft;
+    Framework::Button* recipies;
     int currentTooltipSlot;
     int requestetTooltipSlot;
-    int getSlotByLocalPos(Framework::Punkt pos);
+    int getSlotByLocalPos(Framework::Point pos);
 
 public:
     CraftingGridView(Framework::Text id,
@@ -61,8 +61,8 @@ public:
     ~CraftingGridView();
     void api(char* message) override;
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
     Framework::Either<int, Framework::VecN<int, 4>>
     getInventoryTarget() const override;
 };

FactoryCraft/CraftingRecipies.cpp

@@ -1,6 +1,6 @@
 #include "CraftingRecipies.h"
 
-#include <Bild.h>
+#include <Image.h>
 #include <XML.h>
 
 #include "Globals.h"
@@ -14,11 +14,11 @@ CraftingRecipiesElement::CraftingRecipiesElement()
 //! ist
 bool CraftingRecipiesElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("craftingRecipies");
+    return element.getName().isEqual("craftingRecipies");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* CraftingRecipiesElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* CraftingRecipiesElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     CraftingRecipies* recipies = new CraftingRecipies();
@@ -30,7 +30,7 @@ Framework::Zeichnung* CraftingRecipiesElement::parseElement(
             if (zElement->hasAttribute("itemIcon"))
             {
                 int type = (int)zElement->getAttributeValue("itemIcon");
-                group->setIcon(dynamic_cast<Framework::Bild*>(
+                group->setIcon(dynamic_cast<Framework::Image*>(
                     zItemType(type)->zIcon()->getThis()));
             }
             zElement->selectChildren().forEach(
@@ -44,15 +44,15 @@ Framework::Zeichnung* CraftingRecipiesElement::parseElement(
 }
 
 bool CraftingRecipiesElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void CraftingRecipiesElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -62,17 +62,17 @@ void CraftingRecipiesElement::layout(Framework::XML::Element& element,
     element.selectChildsByName("craftingRecipieGroup")
         .selectChildren()
         .forEach([&z, &generalLayouter](Framework::XML::Element* zElement) {
-            Framework::Zeichnung* child = 0;
+            Framework::Drawable* child = 0;
             if (zElement->hasAttribute("id"))
             {
-                child = generalLayouter.zZeichnungById(
+                child = generalLayouter.zDrawableById(
                     zElement->getAttributeValue("id"));
             }
             if (child)
             {
                 generalLayouter.layout(*zElement,
                     *child,
-                    z.getBreite(),
+                    z.getWidth(),
                     z.getHeight(),
                     generalLayouter);
             }
@@ -80,30 +80,30 @@ void CraftingRecipiesElement::layout(Framework::XML::Element& element,
 }
 
 CraftingRecipies::CraftingRecipies()
-    : Framework::ZeichnungHintergrund()
+    : Framework::DrawableBackground()
 {
-    setStyle(Framework::Zeichnung::Style::Erlaubt
-             | Framework::Zeichnung::Style::Sichtbar);
+    setStyle(Framework::Drawable::Style::Allowed
+             | Framework::Drawable::Style::Visible);
 
-    previousPage = uiFactory.createKnopf(uiFactory.initParam);
+    previousPage = uiFactory.createButton(uiFactory.initParam);
     previousPage->setText("<");
     previousPage->setToolTipText("Previous Page",
         uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
+        uiFactory.initParam.font);
     previousPage->setSize(20, 20);
     previousPage->setPosition(0, 35);
     previousPage->setStyle(
-        Framework::Knopf::Style::Normal & ~Framework::Knopf::Style::Sichtbar);
-    previousPage->setMausEreignis([this](void* p, void* z, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        Framework::Button::Style::Normal & ~Framework::Button::Style::Visible);
+    previousPage->setMouseEvent([this](void* p, void* z, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             RecipieGroup* previous = 0;
             for (RecipieGroup* group : recipieGroups)
             {
-                if (group->hatStyle(Zeichnung::Style::Sichtbar) && previous)
+                if (group->hasStyle(Drawable::Style::Visible) && previous)
                 {
-                    group->removeStyle(Zeichnung::Style::Sichtbar);
-                    previous->addStyle(Zeichnung::Style::Sichtbar);
+                    group->removeStyle(Drawable::Style::Visible);
+                    previous->addStyle(Drawable::Style::Visible);
                 }
                 previous = group;
             }
@@ -111,17 +111,17 @@ CraftingRecipies::CraftingRecipies()
         return 1;
     });
 
-    nextPage = uiFactory.createKnopf(uiFactory.initParam);
+    nextPage = uiFactory.createButton(uiFactory.initParam);
     nextPage->setText(">");
     nextPage->setToolTipText("Next Page",
         uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
+        uiFactory.initParam.font);
     nextPage->setSize(20, 20);
     nextPage->setPosition(0, 35);
     nextPage->setStyle(
-        Framework::Knopf::Style::Normal & ~Framework::Knopf::Style::Sichtbar);
-    nextPage->setMausEreignis([this](void* p, void* z, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        Framework::Button::Style::Normal & ~Framework::Button::Style::Visible);
+    nextPage->setMouseEvent([this](void* p, void* z, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             bool next = 0;
             int index = 0;
@@ -129,13 +129,13 @@ CraftingRecipies::CraftingRecipies()
             {
                 if (next)
                 {
-                    group->addStyle(Zeichnung::Style::Sichtbar);
+                    group->addStyle(Drawable::Style::Visible);
                     break;
                 }
-                if (group->hatStyle(Zeichnung::Style::Sichtbar)
-                    && recipieGroups.getEintragAnzahl() > index + 1)
+                if (group->hasStyle(Drawable::Style::Visible)
+                    && recipieGroups.getEntryCount() > index + 1)
                 {
-                    group->removeStyle(Zeichnung::Style::Sichtbar);
+                    group->removeStyle(Drawable::Style::Visible);
                     next = 1;
                 }
                 index++;
@@ -156,82 +156,82 @@ bool CraftingRecipies::tick(double tickVal)
     int index = 0;
     for (RecipieGroup* group : recipieGroups)
     {
-        if (group->hatStyle(Zeichnung::Style::Sichtbar))
+        if (group->hasStyle(Drawable::Style::Visible))
         {
             visibleGroupIndex = index;
         }
         rend |= group->tick(tickVal);
         index++;
     }
-    nextPage->setX(getBreite() - 20);
-    previousPage->setStyle(Knopf::Style::Sichtbar, visibleGroupIndex > 0);
-    nextPage->setStyle(Knopf::Style::Sichtbar,
-        visibleGroupIndex < recipieGroups.getEintragAnzahl() - 1);
+    nextPage->setX(getWidth() - 20);
+    previousPage->setStyle(Button::Style::Visible, visibleGroupIndex > 0);
+    nextPage->setStyle(Button::Style::Visible,
+        visibleGroupIndex < recipieGroups.getEntryCount() - 1);
     rend |= previousPage->tick(tickVal);
     rend |= nextPage->tick(tickVal);
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void CraftingRecipies::render(Framework::Bild& rObj)
+void CraftingRecipies::render(Framework::Image& rObj)
 {
-    if (!hatStyle(Zeichnung::Style::Sichtbar)) return;
-    ZeichnungHintergrund::render(rObj);
+    if (!hasStyle(Drawable::Style::Visible)) return;
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     int visibleGroupIndex = -1;
     int index = 0;
     for (RecipieGroup* group : recipieGroups)
     {
-        if (group->hatStyle(Zeichnung::Style::Sichtbar))
+        if (group->hasStyle(Drawable::Style::Visible))
         {
             visibleGroupIndex = index;
         }
         group->setPosition(0, 60);
-        group->setSize(getBreite(), getHeight() - 60);
+        group->setSize(getWidth(), getHeight() - 60);
         group->render(rObj);
         index++;
     }
-    int totalWidth = recipieGroups.getEintragAnzahl() * 31 + 1;
-    int possibleDisplayedIcons = getBreite() / 31;
+    int totalWidth = recipieGroups.getEntryCount() * 31 + 1;
+    int possibleDisplayedIcons = getWidth() / 31;
     int x = 0;
-    if (possibleDisplayedIcons < recipieGroups.getEintragAnzahl()
+    if (possibleDisplayedIcons < recipieGroups.getEntryCount()
         && visibleGroupIndex > possibleDisplayedIcons / 2)
     {
         x = (visibleGroupIndex - possibleDisplayedIcons / 2) * -31;
-        if (recipieGroups.getEintragAnzahl() * 31 + 1 + x < getBreite())
+        if (recipieGroups.getEntryCount() * 31 + 1 + x < getWidth())
         {
-            x += getBreite() - (recipieGroups.getEintragAnzahl() * 31 + 1 + x);
+            x += getWidth() - (recipieGroups.getEntryCount() * 31 + 1 + x);
         }
     }
     index = 0;
     for (RecipieGroup* group : recipieGroups)
     {
         rObj.fillRegion(x, 0, 30, 30, 0xFF000000);
-        rObj.alphaBildSkall(x, 0, 30, 30, *group->zIcon());
-        rObj.drawLinieH(x - 1, 0, 32, 0xFFFFFFFF);
+        rObj.alphaImageScaled(x, 0, 30, 30, *group->zIcon());
+        rObj.drawLineH(x - 1, 0, 32, 0xFFFFFFFF);
         if (index != visibleGroupIndex)
         {
-            rObj.drawLinieH(x - 1, 30, 32, 0xFFFFFFFF);
+            rObj.drawLineH(x - 1, 30, 32, 0xFFFFFFFF);
         }
-        rObj.drawLinieV(x + 30, 0, 30, 0xFFFFFFFF);
+        rObj.drawLineV(x + 30, 0, 30, 0xFFFFFFFF);
     }
-    Framework::TextRenderer tr(dynamic_cast<Framework::Schrift*>(
-        uiFactory.initParam.schrift->getThis()));
-    tr.setSchriftSize(12);
+    Framework::TextRenderer tr(dynamic_cast<Framework::Font*>(
+        uiFactory.initParam.font->getThis()));
+    tr.setFontSize(12);
     Text t = Text("Machine page ") + Text(visibleGroupIndex + 1) + Text(" of ")
-           + Text(recipieGroups.getEintragAnzahl());
-    int tbr = tr.getTextBreite(t);
-    tr.renderText(getBreite() / 2 - tbr / 2, 34, t, rObj, 0xFFFFFFFF);
+           + Text(recipieGroups.getEntryCount());
+    int tbr = tr.getTextWidth(t);
+    tr.renderText(getWidth() / 2 - tbr / 2, 34, t, rObj, 0xFFFFFFFF);
     previousPage->render(rObj);
     nextPage->render(rObj);
     rObj.releaseDrawOptions();
 }
 
-void CraftingRecipies::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void CraftingRecipies::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    previousPage->doPublicMausEreignis(me);
-    nextPage->doPublicMausEreignis(me);
+    previousPage->doPublicMouseEvent(me);
+    nextPage->doPublicMouseEvent(me);
     for (RecipieGroup* group : recipieGroups)
     {
-        group->doPublicMausEreignis(me);
+        group->doPublicMouseEvent(me);
     }
 }

FactoryCraft/CraftingRecipies.h

@@ -11,26 +11,26 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class CraftingRecipies : public Framework::ZeichnungHintergrund
+class CraftingRecipies : public Framework::DrawableBackground
 {
 private:
     Framework::RCArray<RecipieGroup> recipieGroups;
-    Framework::Knopf* previousPage;
-    Framework::Knopf* nextPage;
+    Framework::Button* previousPage;
+    Framework::Button* nextPage;
 
 public:
     CraftingRecipies();
@@ -38,6 +38,6 @@ public:
     void addRecipieGroup(RecipieGroup* recipieGroup);
 
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };

FactoryCraft/CustomDX11API.cpp

@@ -36,11 +36,11 @@ Framework::DX11VertexShader* CustomDX11API::initializeVertexShader(
         (unsigned char*)CustomUIDX11VertexShader,
         sizeof(CustomUIDX11VertexShader));
     vertexShaderLightBufferIndex = shader->getFirstUninitializedBufferIndex();
-    shader->erstelleConstBuffer(20, vertexShaderLightBufferIndex);
+    shader->createConstBuffer(20, vertexShaderLightBufferIndex);
     char buffer[8];
     *(int*)buffer = 0;
     *(float*)(buffer + 4) = 1.f;
-    shader->füllConstBuffer(buffer, vertexShaderLightBufferIndex, 8);
+    shader->fillConstBuffer(buffer, vertexShaderLightBufferIndex, 8);
     return shader;
 }
 

FactoryCraft/Dialog.cpp

@@ -1,9 +1,9 @@
 #include "Dialog.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 #include <InMemoryBuffer.h>
-#include <TastaturEreignis.h>
-#include <TextFeld.h>
+#include <KeyboardEvent.h>
+#include <TextField.h>
 #include <XML.h>
 
 #include "CraftingGrid.h"
@@ -25,13 +25,13 @@ using namespace Framework;
 
 UIMLDialog::UIMLDialog(
     Framework::Text uiml, std::function<void(UIMLDialog* self)> onClose)
-    : Fenster()
+    : Window()
 {
     XML::Element* xml = new XML::Element(uiml);
     view = new UIMLView("<v/>", uiFactory);
-    view->setStyle(UIMLView::Style::Erlaubt | UIMLView::Style::Sichtbar
+    view->setStyle(UIMLView::Style::Allowed | UIMLView::Style::Visible
                    | UIMLView::Style::GlobalMouseEvent);
-    view->setMausEreignis(_ret1ME);
+    view->setMouseEvent(_ret1ME);
     view->addKnownElement(new InventoryElement());
     view->addKnownElement(new EquipmentElement());
     view->addKnownElement(new CraftingGridElement());
@@ -47,9 +47,9 @@ UIMLDialog::UIMLDialog(
     view->addKnownElement(new UIMLCraftingProgressElement());
     view->addKnownElement(new UIMLFuelStateElement());
     view->setOnMemberMouseEvent([](Framework::XML::Element& element,
-                                    Framework::Zeichnung& z,
-                                    MausEreignis me) {
-        if (me.id == ME_RLinks)
+                                    Framework::Drawable& z,
+                                    MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             Framework::Text onClick = element.getAttributeValue("onClick");
             if (onClick.getLength() == 0)
@@ -57,19 +57,19 @@ UIMLDialog::UIMLDialog(
                 return !element.hasAttribute("onClick");
             }
             Framework::Text* dialogName
-                = onClick.getTeilText(0, onClick.positionVon(";"));
+                = onClick.getTeilText(0, onClick.positionOf(";"));
             Framework::Text* tail
-                = onClick.getTeilText(onClick.positionVon(";") + 1);
+                = onClick.getTeilText(onClick.positionOf(";") + 1);
             Framework::InMemoryBuffer buffer;
-            buffer.schreibe("\0", 1); // element message
+            buffer.write("\0", 1); // element message
             while (tail->getLength() > 0)
             {
                 Framework::Text* current = 0;
-                if (tail->positionVon(";") >= 0)
+                if (tail->positionOf(";") >= 0)
                 {
-                    current = tail->getTeilText(0, tail->positionVon(";"));
+                    current = tail->getTeilText(0, tail->positionOf(";"));
                     Framework::Text* tmp
-                        = tail->getTeilText(tail->positionVon(";") + 1);
+                        = tail->getTeilText(tail->positionOf(";") + 1);
                     tail->release();
                     tail = tmp;
                 }
@@ -78,52 +78,52 @@ UIMLDialog::UIMLDialog(
                     current = new Text(*tail);
                     tail->setText("");
                 }
-                if (current->positionVon("(char)") == 0)
+                if (current->positionOf("(char)") == 0)
                 {
-                    current->ersetzen("(char)", "");
+                    current->replace("(char)", "");
                     char d = (char)(int)*current;
-                    buffer.schreibe(&d, 1);
+                    buffer.write(&d, 1);
                 }
-                else if (current->positionVon("(short)") == 0)
+                else if (current->positionOf("(short)") == 0)
                 {
-                    current->ersetzen("(short)", "");
+                    current->replace("(short)", "");
                     short d = (short)(int)*current;
-                    buffer.schreibe((char*)&d, 2);
+                    buffer.write((char*)&d, 2);
                 }
-                else if (current->positionVon("(int)") == 0)
+                else if (current->positionOf("(int)") == 0)
                 {
-                    current->ersetzen("(int)", "");
+                    current->replace("(int)", "");
                     int d = (int)*current;
-                    buffer.schreibe((char*)&d, 4);
+                    buffer.write((char*)&d, 4);
                 }
-                else if (current->positionVon("(__int64)") == 0)
+                else if (current->positionOf("(__int64)") == 0)
                 {
-                    current->ersetzen("(__int64)", "");
+                    current->replace("(__int64)", "");
                     __int64 d = (__int64)*current;
-                    buffer.schreibe((char*)&d, 8);
+                    buffer.write((char*)&d, 8);
                 }
-                else if (current->positionVon("(float)") == 0)
+                else if (current->positionOf("(float)") == 0)
                 {
-                    current->ersetzen("(float)", "");
+                    current->replace("(float)", "");
                     float d = (float)*current;
-                    buffer.schreibe((char*)&d, 4);
+                    buffer.write((char*)&d, 4);
                 }
-                else if (current->positionVon("(double)") == 0)
+                else if (current->positionOf("(double)") == 0)
                 {
-                    current->ersetzen("(double)", "");
+                    current->replace("(double)", "");
                     double d = (double)*current;
-                    buffer.schreibe((char*)&d, 8);
+                    buffer.write((char*)&d, 8);
                 }
                 else
                 {
                     unsigned char len = (unsigned char)current->getLength();
-                    buffer.schreibe((char*)&len, 1);
-                    buffer.schreibe(*current, len);
+                    buffer.write((char*)&len, 1);
+                    buffer.write(*current, len);
                 }
                 current->release();
             }
             char* message = new char[buffer.getSize()];
-            buffer.lese(message, (int)buffer.getSize());
+            buffer.read(message, (int)buffer.getSize());
             World::INSTANCE->zClient()->uiRequest(
                 *dialogName, message, (int)buffer.getSize());
             delete[] message;
@@ -143,7 +143,7 @@ UIMLDialog::UIMLDialog(
     }
     if (!xml->hasAttribute("height"))
     {
-        view->setSize(view->getBreite(), view->calculateContentSize().y);
+        view->setSize(view->getWidth(), view->calculateContentSize().y);
     }
     bool notifyOnClose = 0;
     int notifyOnCloseDimension = -1;
@@ -152,14 +152,14 @@ UIMLDialog::UIMLDialog(
     {
         notifyOnClose = 1;
         Text value = xml->getAttributeValue("notifyOnClose");
-        if (value.hat(","))
+        if (value.has(","))
         {
-            Text* first = value.getTeilText(0, value.positionVon(",", 0) + 1);
+            Text* first = value.getTeilText(0, value.positionOf(",", 0) + 1);
             Text* second = value.getTeilText(
-                value.positionVon(",", 0) + 1, value.positionVon(",", 1));
+                value.positionOf(",", 0) + 1, value.positionOf(",", 1));
             Text* third = value.getTeilText(
-                value.positionVon(",", 1) + 1, value.positionVon(",", 2));
-            Text* forth = value.getTeilText(value.positionVon(",", 2) + 1);
+                value.positionOf(",", 1) + 1, value.positionOf(",", 2));
+            Text* forth = value.getTeilText(value.positionOf(",", 2) + 1);
             notifyOnCloseDimension = (int)*first;
             notifyOnCloseBlock.x = (int)*second;
             notifyOnCloseBlock.y = (int)*third;
@@ -172,25 +172,24 @@ UIMLDialog::UIMLDialog(
     }
     addMember(view);
 
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    setStyle(
-        Fenster::Style::Sichtbar | Fenster::Style::Erlaubt
-        | Fenster::Style::Rahmen | Fenster::Style::BodyHAlpha
-        | Fenster::Style::Beweglich | Fenster::Style::Titel
-        | Fenster::Style::TitelHAlpha | Fenster::Style::Closable
-        | Fenster::Style::ClosingHAlpha | Fenster::Style::ClosingKlickBuffer
-        | Fenster::Style::TitelHintergrund | Fenster::Style::BodyHintergrund
-        | Fenster::Style::ClosingHintergrund | Fenster::Style::MEIgnoreInside
-        | Style::ClosingBuffer | Style::ClosingHBild);
-    setKBgFarbe(0xA0000000);
-    setTBgFarbe(0xA0000000);
-    setSBgFarbe(0xA0000000);
-    setSize(view->getBreite() + 4, view->getHeight() + 24);
-    setPosition(window->zBildschirm()->getBackBufferSize() / 2 - getSize() / 2);
-    setRBreite(2);
+    setStyle(Window::Style::Visible | Window::Style::Allowed
+             | Window::Style::Border | Window::Style::BodyBAlpha
+             | Window::Style::Movable | Window::Style::Title
+             | Window::Style::TitleBAlpha | Window::Style::Closable
+             | Window::Style::ClosingBAlpha | Window::Style::ClosingBuffer
+             | Window::Style::TitleBackground | Window::Style::BodyBackground
+             | Window::Style::ClosingBackground | Window::Style::MEIgnoreInside
+             | Style::ClosingBuffer | Style::ClosingBImage);
+    setBodyBgColor(0xA0000000);
+    setTBgColor(0xA0000000);
+    setCloseBgColor(0xA0000000);
+    setSize(view->getWidth() + 4, view->getHeight() + 24);
+    setPosition(window->zScreen()->getBackBufferSize() / 2 - getSize() / 2);
+    setBorderWidth(2);
     this->onClose = [onClose,
                         notifyOnClose,
                         notifyOnCloseDimension,
@@ -216,25 +215,24 @@ UIMLDialog::UIMLDialog(
     };
     setClosingMe(
         [notifyOnClose, notifyOnCloseDimension, notifyOnCloseBlock, this](
-            void* p, void* o, MausEreignis me) {
-            if (me.id == ME_RLinks)
+            void* p, void* o, MouseEvent me) {
+            if (me.id == ME_RLeft)
             {
                 this->close();
             }
             return 1;
         });
-    setRFarbe(0xFF52525E);
+    setBorderColor(0xFF52525E);
     setTitel(xml->getAttributeValue("title"));
-    setTSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    zTTextFeld()->setSize(0, 20);
-    zTTextFeld()->addStyle(TextFeld::Style::Center);
-    setTastaturEreignis(_ret1TE);
-    setSAfStrength(10);
-    setSAfFarbe(0x5F9C0A0A);
-    setSBgBildZ(iconsDat.laden(0, new Text("close.png")));
-    setSKAfFarbe(0xFF9C0A0A);
-    setSKAfStrength(10);
+    setTFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    zTTextField()->setSize(0, 20);
+    zTTextField()->addStyle(TextField::Style::Center);
+    setKeyboardEvent(_ret1TE);
+    setCloseAfStrength(10);
+    setCloseAfColor(0x5F9C0A0A);
+    setCloseBgImageZ(iconsDat.load(0, new Text("close.png")));
+    setCloseClickAfColor(0xFF9C0A0A);
+    setCloseClickAfStrength(10);
 }
 
 UIMLDialog::~UIMLDialog() {}
@@ -246,7 +244,7 @@ void UIMLDialog::api(char* message)
     memcpy(id, message + 2, idLen);
     id[idLen] = 0;
     NetworkAPIProcessor* processor
-        = dynamic_cast<NetworkAPIProcessor*>(view->zZeichnungById(id));
+        = dynamic_cast<NetworkAPIProcessor*>(view->zDrawableById(id));
     if (processor
         && (*(int*)(message + 2 + idLen) == -1 // global message
             || processor->getId() == *(int*)(message + 2 + idLen)))
@@ -275,10 +273,10 @@ void UIMLDialog::updateUIML(const char* uiml)
         }
         if (!xml->hasAttribute("height"))
         {
-            view->setSize(view->getBreite(), view->calculateContentSize().y);
+            view->setSize(view->getWidth(), view->calculateContentSize().y);
         }
-        Punkt oldSize = getSize();
-        setSize(view->getBreite() + 4, view->getHeight() + 24);
+        Point oldSize = getSize();
+        setSize(view->getWidth() + 4, view->getHeight() + 24);
         setPosition(getPosition() + (oldSize - getSize()) / 2);
     });
 }

FactoryCraft/Dialog.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <Fenster.h>
+#include <Window.h>
 #include <UIMLView.h>
 
 #include "NetworkAPIProcessor.h"
 
-class UIMLDialog : public Framework::Fenster,
+class UIMLDialog : public Framework::Window,
                    public NetworkAPIProcessor
 {
 private:

FactoryCraft/Dimension.cpp

@@ -1,7 +1,8 @@
 #include "Dimension.h"
 
+#include <File.h>
+
 #include "Constants.h"
-#include "Datei.h"
 #include "Game.h"
 #include "Globals.h"
 #include "World.h"
@@ -52,13 +53,13 @@ void Dimension::setId(int id)
     this->id = id;
 }
 
-void Dimension::getAddrOf(Punkt cPos, char* addr) const
+void Dimension::getAddrOf(Point cPos, char* addr) const
 {
     *(int*)addr = cPos.x;
     *((int*)addr + 1) = cPos.y;
 }
 
-void Dimension::getAddrOfWorld(Punkt wPos, char* addr) const
+void Dimension::getAddrOfWorld(Point wPos, char* addr) const
 {
     if (wPos.x < 0) wPos.x -= CHUNK_SIZE;
     if (wPos.y < 0) // needed because otherwise would (-8, -8) have the same
@@ -77,7 +78,7 @@ void Dimension::api(char* message)
             int cX = *(int*)(message + 1);
             int cY = *(int*)(message + 5);
             cs.lock();
-            Chunk* ch = zChunk(Punkt(cX, cY));
+            Chunk* ch = zChunk(Point(cX, cY));
             if (ch) ch->api(message + 9);
             cs.unlock();
             break;
@@ -104,17 +105,17 @@ void Dimension::api(char* message)
         }
     case 4: // add new chunck
         {
-            Punkt center;
+            Point center;
             center.x = *(int*)(message + 1);
             center.y = *(int*)(message + 5);
             ByteArrayReader reader(message + 9, INT_MAX, 0);
             std::cout << "downloading chunk " << center.x << ", " << center.y
                       << "\n";
-            ZeitMesser zm;
-            zm.messungStart();
+            Timer zm;
+            zm.measureStart();
             World::INSTANCE->lockWorld();
             Chunk* chunk = new Chunk(center, &reader);
-            zm.messungEnde();
+            zm.measureEnd();
             std::cout << "chunk loading took " << zm.getSekunden()
                       << " seconds\n";
             cs.lock();
@@ -177,7 +178,7 @@ void Dimension::api(char* message)
     }
 }
 
-Chunk* Dimension::zChunk(Punkt wPos) const
+Chunk* Dimension::zChunk(Point wPos) const
 {
     char addr[8];
     getAddrOfWorld(wPos, addr);
@@ -212,7 +213,7 @@ void Dimension::addEntity(Entity* entity)
     World::INSTANCE->setVisibility(entity, 1);
 }
 
-void Dimension::setChunk(Chunk* chunk, Punkt center)
+void Dimension::setChunk(Chunk* chunk, Point center)
 {
     char addr[8];
     getAddrOfWorld(center, addr);
@@ -241,10 +242,10 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
 
 bool Dimension::hasChunck(int x, int y) const
 {
-    return zChunk(Punkt(x, y));
+    return zChunk(Point(x, y));
 }
 
-void Dimension::removeDistantChunks(Punkt wPos)
+void Dimension::removeDistantChunks(Point wPos)
 {
     Array<int> removed;
     int index = 0;

FactoryCraft/Dimension.h

@@ -17,8 +17,8 @@ private:
     Framework::Array<Chunk*> chunkList;
     Framework::RCArray<Entity>* entities;
     Framework::Critical cs;
-    void getAddrOf(Framework::Punkt cPos, char* addr) const;
-    void getAddrOfWorld(Framework::Punkt wPos, char* addr) const;
+    void getAddrOf(Framework::Point cPos, char* addr) const;
+    void getAddrOfWorld(Framework::Point wPos, char* addr) const;
 
 public:
     Dimension();
@@ -33,10 +33,10 @@ public:
     Block* zBlock(Framework::Vec3<int> location);
     Block* getBlock(Framework::Vec3<int> location);
     void addEntity(Entity* entity);
-    void setChunk(Chunk* chunk, Framework::Punkt center);
+    void setChunk(Chunk* chunk, Framework::Point center);
     bool hasChunck(int x, int y) const;
-    Chunk* zChunk(Framework::Punkt wPos) const;
-    void removeDistantChunks(Framework::Punkt wPos);
+    Chunk* zChunk(Framework::Point wPos) const;
+    void removeDistantChunks(Framework::Point wPos);
     void setBlock(Block* block);
     void removeBlock(Block* zBlock);
     Entity* zEntity(int id);

FactoryCraft/DimensionMap.cpp

@@ -1,13 +1,13 @@
 #include "DimensionMap.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 
 #include "Constants.h"
 #include "Globals.h"
 #include "World.h"
 
 DimensionMap::DimensionMap(MapOptions* zOptions)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       zOptions(zOptions),
       originChunkCenter(0, 0),
       scrollOffset(0, 0),
@@ -17,9 +17,9 @@ DimensionMap::DimensionMap(MapOptions* zOptions)
       drag(0),
       nextPlayersRequest(-1)
 {
-    setStyle(Style::Sichtbar | Style::Erlaubt);
+    setStyle(Style::Visible | Style::Allowed);
     chunks = new Framework::RCTrie<ChunkMap>();
-    setMausEreignis(_ret1ME);
+    setMouseEvent(_ret1ME);
     requestNextChunk();
 
     char msg[2];
@@ -27,11 +27,11 @@ DimensionMap::DimensionMap(MapOptions* zOptions)
     msg[1] = 1;
     World::INSTANCE->zClient()->dimensionAPIRequest(msg, 2);
 
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    playerIcon = iconsDat.laden(0, new Text("player.png"));
+    playerIcon = iconsDat.load(0, new Text("player.png"));
 }
 
 DimensionMap::~DimensionMap()
@@ -44,13 +44,13 @@ DimensionMap::~DimensionMap()
     playerIcon->release();
 }
 
-void DimensionMap::getAddrOf(Punkt cPos, char* addr) const
+void DimensionMap::getAddrOf(Point cPos, char* addr) const
 {
     *(int*)addr = cPos.x;
     *((int*)addr + 1) = cPos.y;
 }
 
-void DimensionMap::getAddrOfWorld(Punkt wPos, char* addr) const
+void DimensionMap::getAddrOfWorld(Point wPos, char* addr) const
 {
     // needed because otherwise would (-8, -8) have the same
     // adress as (8, 8)
@@ -61,11 +61,11 @@ void DimensionMap::getAddrOfWorld(Punkt wPos, char* addr) const
     getAddrOf(wPos, addr);
 }
 
-Framework::Punkt DimensionMap::getMinVisibleChunkCenter(
-    Framework::Punkt& screenPos) const
+Framework::Point DimensionMap::getMinVisibleChunkCenter(
+    Framework::Point& screenPos) const
 {
     screenPos = getSize() / 2 - scrollOffset;
-    Punkt currentChunkCenter = originChunkCenter;
+    Point currentChunkCenter = originChunkCenter;
     while (screenPos.x + pixelsPerBlock * (CHUNK_SIZE / 2) >= 0)
     {
         screenPos.x -= pixelsPerBlock * CHUNK_SIZE;
@@ -89,12 +89,12 @@ Framework::Punkt DimensionMap::getMinVisibleChunkCenter(
     return currentChunkCenter;
 }
 
-Framework::Punkt DimensionMap::getMaxVisibleChunkCenter(
-    Framework::Punkt& screenPos) const
+Framework::Point DimensionMap::getMaxVisibleChunkCenter(
+    Framework::Point& screenPos) const
 {
     screenPos = getSize() / 2 - scrollOffset;
-    Punkt currentChunkCenter = originChunkCenter;
-    while (screenPos.x - pixelsPerBlock * (CHUNK_SIZE / 2) < getBreite())
+    Point currentChunkCenter = originChunkCenter;
+    while (screenPos.x - pixelsPerBlock * (CHUNK_SIZE / 2) < getWidth())
     {
         screenPos.x += pixelsPerBlock * CHUNK_SIZE;
         currentChunkCenter.x += CHUNK_SIZE;
@@ -104,7 +104,7 @@ Framework::Punkt DimensionMap::getMaxVisibleChunkCenter(
         screenPos.y += pixelsPerBlock * CHUNK_SIZE;
         currentChunkCenter.y += CHUNK_SIZE;
     }
-    while (screenPos.x - pixelsPerBlock * (CHUNK_SIZE / 2) >= getBreite())
+    while (screenPos.x - pixelsPerBlock * (CHUNK_SIZE / 2) >= getWidth())
     {
         screenPos.x -= pixelsPerBlock * CHUNK_SIZE;
         currentChunkCenter.x -= CHUNK_SIZE;
@@ -119,11 +119,11 @@ Framework::Punkt DimensionMap::getMaxVisibleChunkCenter(
 
 void DimensionMap::removeUnused() const
 {
-    Punkt tmp;
-    Framework::Punkt min
-        = getMinVisibleChunkCenter(tmp) - Punkt(CHUNK_SIZE, CHUNK_SIZE) * 5;
-    Framework::Punkt max
-        = getMaxVisibleChunkCenter(tmp) + Punkt(CHUNK_SIZE, CHUNK_SIZE) * 5;
+    Point tmp;
+    Framework::Point min
+        = getMinVisibleChunkCenter(tmp) - Point(CHUNK_SIZE, CHUNK_SIZE) * 5;
+    Framework::Point max
+        = getMaxVisibleChunkCenter(tmp) + Point(CHUNK_SIZE, CHUNK_SIZE) * 5;
     char addr[8];
     for (auto i = chunkList.begin(); i;)
     {
@@ -146,7 +146,7 @@ void DimensionMap::updatePlayers(char* data)
     int count = *(int*)data;
     data += 4;
     cs.lock();
-    players.leeren();
+    players.clear();
     // read player information from data buffer
     for (int i = 0; i < count; i++)
     {
@@ -192,14 +192,14 @@ void DimensionMap::requestNextChunk()
     {
         while (requestCount < 20)
         {
-            Punkt minScreenPos;
-            Punkt minVisibleChunk = getMinVisibleChunkCenter(minScreenPos);
-            Punkt maxScreenPos;
-            Punkt maxVisibleChunk = getMaxVisibleChunkCenter(maxScreenPos);
-            Punkt screenPos = minScreenPos;
-            Punkt screenCenter = getSize() / 2;
+            Point minScreenPos;
+            Point minVisibleChunk = getMinVisibleChunkCenter(minScreenPos);
+            Point maxScreenPos;
+            Point maxVisibleChunk = getMaxVisibleChunkCenter(maxScreenPos);
+            Point screenPos = minScreenPos;
+            Point screenCenter = getSize() / 2;
             double minDist = -1;
-            Punkt resultChunk(0, 0);
+            Point resultChunk(0, 0);
             char addr[8];
             for (int x = minVisibleChunk.x; x <= maxVisibleChunk.x;
                  x += CHUNK_SIZE)
@@ -280,12 +280,12 @@ bool DimensionMap::tick(double time)
         lastSize = getSize();
         requestNextChunk();
     }
-    return ZeichnungHintergrund::tick(time);
+    return DrawableBackground::tick(time);
 }
 
-void DimensionMap::render(Framework::Bild& rObj)
+void DimensionMap::render(Framework::Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(innenPosition, innenSize)) return;
     cs.lock();
     if (zOptions->isFollowPlayer())
@@ -293,17 +293,17 @@ void DimensionMap::render(Framework::Bild& rObj)
         Vec3<float> playerPos
             = World::INSTANCE->getCurrentPlayerEntity()->getPos();
         scrollOffset
-            = (Punkt((int)playerPos.x, (int)playerPos.y) - originChunkCenter)
+            = (Point((int)playerPos.x, (int)playerPos.y) - originChunkCenter)
             * pixelsPerBlock;
         requestNextChunk();
     }
-    Punkt minScreenPos;
-    Punkt minVisibleChunk = getMinVisibleChunkCenter(minScreenPos);
-    Punkt maxScreenPos;
-    Punkt maxVisibleChunk = getMaxVisibleChunkCenter(maxScreenPos);
+    Point minScreenPos;
+    Point minVisibleChunk = getMinVisibleChunkCenter(minScreenPos);
+    Point maxScreenPos;
+    Point maxVisibleChunk = getMaxVisibleChunkCenter(maxScreenPos);
     char addr[8];
     // render chunks
-    Punkt screenPos = minScreenPos;
+    Point screenPos = minScreenPos;
     for (int x = minVisibleChunk.x; x <= maxVisibleChunk.x; x += CHUNK_SIZE)
     {
         for (int y = minVisibleChunk.y; y <= maxVisibleChunk.y; y += CHUNK_SIZE)
@@ -324,9 +324,9 @@ void DimensionMap::render(Framework::Bild& rObj)
                 {
                     map->setMaxHeight(255);
                 }
-                Punkt topLeft(screenPos.x - (pixelsPerBlock * CHUNK_SIZE) / 2,
+                Point topLeft(screenPos.x - (pixelsPerBlock * CHUNK_SIZE) / 2,
                     screenPos.y - (pixelsPerBlock * CHUNK_SIZE) / 2);
-                rObj.drawBildSkall(topLeft.x,
+                rObj.drawImageScaled(topLeft.x,
                     topLeft.y,
                     pixelsPerBlock * CHUNK_SIZE,
                     pixelsPerBlock * CHUNK_SIZE,
@@ -347,7 +347,7 @@ void DimensionMap::render(Framework::Bild& rObj)
             ChunkMap* map = chunks->z(addr, 8);
             if (map)
             {
-                Punkt topLeft(screenPos.x - (pixelsPerBlock * CHUNK_SIZE) / 2,
+                Point topLeft(screenPos.x - (pixelsPerBlock * CHUNK_SIZE) / 2,
                     screenPos.y - (pixelsPerBlock * CHUNK_SIZE) / 2);
                 getAddrOfWorld({x, y - CHUNK_SIZE}, addr);
                 ChunkMap* tmp = chunks->z(addr, 8);
@@ -373,7 +373,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                             if (heightMap[yy * CHUNK_SIZE + xx]
                                 > heightMap[yy * CHUNK_SIZE + xx + 1])
                             {
-                                rObj.drawLinieVAlpha((xx * pixelsPerBlock)
+                                rObj.drawLineVAlpha((xx * pixelsPerBlock)
                                                          + topLeft.x
                                                          + pixelsPerBlock,
                                     (yy * pixelsPerBlock) + topLeft.y,
@@ -387,7 +387,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                             if (heightMap[yy * CHUNK_SIZE + xx]
                                 > heightMapRight[yy * CHUNK_SIZE])
                             {
-                                rObj.drawLinieVAlpha((xx * pixelsPerBlock)
+                                rObj.drawLineVAlpha((xx * pixelsPerBlock)
                                                          + topLeft.x
                                                          + pixelsPerBlock,
                                     (yy * pixelsPerBlock) + topLeft.y,
@@ -401,7 +401,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                             if (heightMap[yy * CHUNK_SIZE + xx]
                                 > heightMap[(yy + 1) * CHUNK_SIZE + xx])
                             {
-                                rObj.drawLinieHAlpha(
+                                rObj.drawLineHAlpha(
                                     (xx * pixelsPerBlock) + topLeft.x,
                                     (yy * pixelsPerBlock) + topLeft.y
                                         + pixelsPerBlock,
@@ -415,7 +415,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                             if (heightMap[yy * CHUNK_SIZE + xx]
                                 > heightMapBottom[xx])
                             {
-                                rObj.drawLinieHAlpha(
+                                rObj.drawLineHAlpha(
                                     (xx * pixelsPerBlock) + topLeft.x,
                                     (yy * pixelsPerBlock) + topLeft.y
                                         + pixelsPerBlock,
@@ -429,7 +429,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                             if (heightMap[yy * CHUNK_SIZE + xx]
                                 > heightMap[yy * CHUNK_SIZE + xx - 1])
                             {
-                                rObj.drawLinieVAlpha(
+                                rObj.drawLineVAlpha(
                                     (xx * pixelsPerBlock) + topLeft.x,
                                     (yy * pixelsPerBlock) + topLeft.y,
                                     pixelsPerBlock - shadowB,
@@ -442,7 +442,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                                 > heightMapLeft[yy * CHUNK_SIZE + CHUNK_SIZE
                                                 - 1])
                             {
-                                rObj.drawLinieVAlpha(
+                                rObj.drawLineVAlpha(
                                     (xx * pixelsPerBlock) + topLeft.x,
                                     (yy * pixelsPerBlock) + topLeft.y,
                                     pixelsPerBlock - shadowB,
@@ -454,7 +454,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                             if (heightMap[yy * CHUNK_SIZE + xx]
                                 > heightMap[(yy - 1) * CHUNK_SIZE + xx])
                             {
-                                rObj.drawLinieHAlpha(
+                                rObj.drawLineHAlpha(
                                     (xx * pixelsPerBlock) + topLeft.x,
                                     (yy * pixelsPerBlock) + topLeft.y,
                                     pixelsPerBlock - shadowR,
@@ -467,7 +467,7 @@ void DimensionMap::render(Framework::Bild& rObj)
                                 > heightMapTop[(CHUNK_SIZE - 1) * CHUNK_SIZE
                                                + xx])
                             {
-                                rObj.drawLinieHAlpha(
+                                rObj.drawLineHAlpha(
                                     (xx * pixelsPerBlock) + topLeft.x,
                                     (yy * pixelsPerBlock) + topLeft.y,
                                     pixelsPerBlock - shadowR,
@@ -478,11 +478,11 @@ void DimensionMap::render(Framework::Bild& rObj)
                 }
                 if (zOptions->isShowChunkBorders())
                 {
-                    rObj.drawLinieHAlpha(topLeft.x,
+                    rObj.drawLineHAlpha(topLeft.x,
                         topLeft.y,
                         pixelsPerBlock * CHUNK_SIZE,
                         0x50FFFFFF);
-                    rObj.drawLinieVAlpha(topLeft.x,
+                    rObj.drawLineVAlpha(topLeft.x,
                         topLeft.y,
                         pixelsPerBlock * CHUNK_SIZE,
                         0x50FFFFFF);
@@ -497,26 +497,26 @@ void DimensionMap::render(Framework::Bild& rObj)
     if (zOptions->isShowPlayers())
     {
         TextRenderer tm(
-            dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-        tm.setSchriftSize(12);
+            dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+        tm.setFontSize(12);
         for (const MapPlayer& player : players)
         {
-            Punkt screenPos
+            Point screenPos
                 = getSize() / 2 - scrollOffset
-                + (Punkt((int)player.position.x, (int)player.position.y)
+                + (Point((int)player.position.x, (int)player.position.y)
                       - originChunkCenter)
                       * pixelsPerBlock
-                + Punkt(pixelsPerBlock, pixelsPerBlock) / 2
+                + Point(pixelsPerBlock, pixelsPerBlock) / 2
                 - playerIcon->getSize() / 2;
-            rObj.alphaBild(screenPos.x,
+            rObj.alphaImage(screenPos.x,
                 screenPos.y,
-                playerIcon->getBreite(),
+                playerIcon->getWidth(),
                 playerIcon->getHeight(),
                 *playerIcon);
-            int textWidth = tm.getTextBreite(player.name);
+            int textWidth = tm.getTextWidth(player.name);
             int textheight = tm.getTextHeight(player.name);
-            screenPos = screenPos + Punkt(playerIcon->getBreite(), 0) / 2
-                      - Punkt(textWidth / 2, textheight + 2);
+            screenPos = screenPos + Point(playerIcon->getWidth(), 0) / 2
+                      - Point(textWidth / 2, textheight + 2);
             rObj.alphaRegion(
                 screenPos.x, screenPos.y, textWidth, textheight, 0x70000000);
             tm.renderText(
@@ -527,18 +527,18 @@ void DimensionMap::render(Framework::Bild& rObj)
     rObj.releaseDrawOptions();
 }
 
-void DimensionMap::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void DimensionMap::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    if (me.id == ME_PLinks)
+    if (me.id == ME_PLeft)
     {
         drag = 1;
         lastMouse = {me.mx, me.my};
     }
-    if (me.id == ME_RLinks || me.id == ME_Leaves) drag = 0;
-    if (me.id == ME_Bewegung && drag)
+    if (me.id == ME_RLeft || me.id == ME_Leaves) drag = 0;
+    if (me.id == ME_Move && drag)
     {
-        scrollOffset -= Punkt(me.mx, me.my) - lastMouse;
-        lastMouse = Punkt(me.mx, me.my);
+        scrollOffset -= Point(me.mx, me.my) - lastMouse;
+        lastMouse = Point(me.mx, me.my);
         rend = 1;
         requestNextChunk();
     }
@@ -556,5 +556,5 @@ void DimensionMap::doMausEreignis(Framework::MausEreignis& me, bool userRet)
         rend = 1;
         requestNextChunk();
     }
-    ZeichnungHintergrund::doMausEreignis(me, userRet);
+    DrawableBackground::doMouseEvent(me, userRet);
 }

FactoryCraft/DimensionMap.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Trie.h>
-#include <Zeichnung.h>
+#include <Drawing.h>
 
 #include "ChunkMap.h"
 #include "MapOptions.h"
@@ -12,30 +12,30 @@ struct MapPlayer
     Framework::Text name;
 };
 
-class DimensionMap : public Framework::ZeichnungHintergrund
+class DimensionMap : public Framework::DrawableBackground
 {
 private:
     MapOptions* zOptions;
     Framework::RCTrie<ChunkMap>* chunks;
     Framework::Array<ChunkMap*> chunkList;
-    Framework::Punkt originChunkCenter;
-    Framework::Punkt scrollOffset;
+    Framework::Point originChunkCenter;
+    Framework::Point scrollOffset;
     int chunkCount;
     int pixelsPerBlock;
     int requestCount;
     bool drag;
-    Framework::Punkt lastMouse;
-    Framework::Punkt lastSize;
+    Framework::Point lastMouse;
+    Framework::Point lastSize;
     Framework::Array<MapPlayer> players;
     double nextPlayersRequest;
-    Framework::Bild* playerIcon;
+    Framework::Image* playerIcon;
 
-    void getAddrOf(Framework::Punkt cPos, char* addr) const;
-    void getAddrOfWorld(Framework::Punkt wPos, char* addr) const;
-    Framework::Punkt getMinVisibleChunkCenter(
-        Framework::Punkt& screenPos) const;
-    Framework::Punkt getMaxVisibleChunkCenter(
-        Framework::Punkt& screenPos) const;
+    void getAddrOf(Framework::Point cPos, char* addr) const;
+    void getAddrOfWorld(Framework::Point wPos, char* addr) const;
+    Framework::Point getMinVisibleChunkCenter(
+        Framework::Point& screenPos) const;
+    Framework::Point getMaxVisibleChunkCenter(
+        Framework::Point& screenPos) const;
     void removeUnused() const;
 
 public:
@@ -46,6 +46,6 @@ public:
     void requestNextChunk();
     void addChunk(ChunkMap* chunk);
     bool tick(double time) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };

FactoryCraft/DragController.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <Bild.h>
-#include <Zeichnung.h>
+#include <Image.h>
+#include <Drawing.h>
 
 #include "DragElement.h"
 #include "Globals.h"
@@ -32,14 +32,14 @@ public:
 
     void beginDrag(Source* container,
         Element element,
-        Framework::Bild* zDragDisplay,
+        Framework::Image* zDragDisplay,
         std::function<void()> onDragEnd)
     {
         if (this->container) stopDrag();
-        ((Framework::BildZ*)drag)
-            ->setBildZ(dynamic_cast<Framework::Bild*>(zDragDisplay->getThis()));
-        window->zBildschirm()->addMember(
-            dynamic_cast<Zeichnung*>(drag->getThis()));
+        ((Framework::ImageView*)drag)
+            ->setImageZ(dynamic_cast<Framework::Image*>(zDragDisplay->getThis()));
+        window->zScreen()->addMember(
+            dynamic_cast<Drawable*>(drag->getThis()));
         this->container = container;
         this->currentElement = element;
         this->onDragEnd = onDragEnd;
@@ -59,7 +59,7 @@ public:
     {
         if (container)
         {
-            window->zBildschirm()->removeMember(drag);
+            window->zScreen()->removeMember(drag);
             onDragEnd();
             container = 0;
             currentElement = 0;

FactoryCraft/DragElement.cpp

@@ -1,18 +1,18 @@
-#include <MausEreignis.h>
+#include <MouseEvent.h>
 
 #include "DragElement.h"
 
 using namespace Framework;
 
 DragElement::DragElement()
-	: BildZ()
+	: ImageView()
 {
-	setStyle(BildZ::Style::Sichtbar | BildZ::Style::Alpha | BildZ::Style::Skalliert | BildZ::Style::Erlaubt | BildZ::Style::MEIgnoreVerarbeitet | BildZ::Style::MEIgnoreInside | BildZ::Style::MEIgnoreParentInside);
+	setStyle(ImageView::Style::Visible | ImageView::Style::Alpha | ImageView::Style::Scaled | ImageView::Style::Allowed | ImageView::Style::MEIgnoreProcessed | ImageView::Style::MEIgnoreInside | ImageView::Style::MEIgnoreParentInside);
 	setSize(50, 50);
-	setMausEreignis(_ret1ME);
+	setMouseEvent(_ret1ME);
 }
 
-void DragElement::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void DragElement::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
 	setPosition(pos.x + me.mx, pos.y + me.my);
 }

FactoryCraft/DragElement.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <Bild.h>
+#include <Image.h>
 
-class DragElement : public Framework::BildZ
+class DragElement : public Framework::ImageView
 {
 public:
     DragElement();
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };

FactoryCraft/Entity.cpp

@@ -8,7 +8,7 @@
 
 Entity::Entity(const EntityType* zType,
     Framework::Model3DData* model,
-    Framework::Model3DTextur* texture,
+    Framework::Model3DTexture* texture,
     int id,
     Framework::Vec3<float> position,
     float size)
@@ -19,7 +19,7 @@ Entity::Entity(const EntityType* zType,
       frameLength(0.f)
 {
     pos = position;
-    setModelDaten(model);
+    setModelData(model);
     setModelTextur(texture);
     currentFrame.duration = 0;
     rend = 1;
@@ -66,7 +66,7 @@ bool Entity::tick(double time)
     {
         if (currentFrame.duration <= 0)
         {
-            if (frames.getEintragAnzahl() > 0)
+            if (frames.getEntryCount() > 0)
             {
                 currentFrame = frames.get(0);
                 frames.remove(0);
@@ -78,23 +78,23 @@ bool Entity::tick(double time)
         }
         float t = min(currentFrame.duration, (float)totalTime);
         pos += (currentFrame.position - pos) * (t / currentFrame.duration);
-        if (getZDrehung() - currentFrame.rotation > (float)PI)
+        if (getZRotation() - currentFrame.rotation > (float)PI)
         {
-            setDrehungZ(getZDrehung() - 2.f * (float)PI);
+            setRotationZ(getZRotation() - 2.f * (float)PI);
         }
-        else if (currentFrame.rotation - getZDrehung() > (float)PI)
+        else if (currentFrame.rotation - getZRotation() > (float)PI)
         {
-            setDrehungZ(getZDrehung() + 2.f * (float)PI);
+            setRotationZ(getZRotation() + 2.f * (float)PI);
         }
-        setDrehungZ(getZDrehung()
-                    + (currentFrame.rotation - getZDrehung())
+        setRotationZ(getZRotation()
+                    + (currentFrame.rotation - getZRotation())
                           * (t / currentFrame.duration));
         currentFrame.duration -= t;
         totalTime -= t;
         if (currentFrame.duration <= 0)
         {
             pos = currentFrame.position;
-            setDrehungZ(currentFrame.rotation);
+            setRotationZ(currentFrame.rotation);
         }
         rend = 1;
     }

FactoryCraft/Entity.h

@@ -31,7 +31,7 @@ private:
 public:
     Entity(const EntityType* zType,
         Framework::Model3DData* model,
-        Framework::Model3DTextur* texture,
+        Framework::Model3DTexture* texture,
         int id,
         Framework::Vec3<float> position,
         float size);

FactoryCraft/EntityType.cpp

@@ -11,13 +11,13 @@ EntityType::EntityType(int id, ModelInfo model)
 Entity* EntityType::loadEntity(Framework::StreamReader* zReader) const
 {
     int id;
-    zReader->lese((char*)&id, 4);
+    zReader->read((char*)&id, 4);
     Framework::Vec3<float> position;
-    zReader->lese((char*)&position.x, 4);
-    zReader->lese((char*)&position.y, 4);
-    zReader->lese((char*)&position.z, 4);
+    zReader->read((char*)&position.x, 4);
+    zReader->read((char*)&position.y, 4);
+    zReader->read((char*)&position.z, 4);
     bool specialModel = 0;
-    zReader->lese((char*)&specialModel, 1);
+    zReader->read((char*)&specialModel, 1);
     Entity* e;
     if (specialModel)
     {

FactoryCraft/Equipment.cpp

@@ -11,26 +11,26 @@ EquipmentElement::EquipmentElement()
 //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig ist
 bool EquipmentElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("equipment");
+    return element.getName().isEqual("equipment");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* EquipmentElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* EquipmentElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     return new EquipmentView((int)element.getAttributeValue("entity"));
 }
 
 bool EquipmentElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void EquipmentElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -39,7 +39,7 @@ void EquipmentElement::layout(Framework::XML::Element& element,
 }
 
 EquipmentView::EquipmentView(int entityId)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       entityId(entityId)
 {}
 
@@ -47,15 +47,15 @@ void EquipmentView::api(char* message) {}
 
 bool EquipmentView::tick(double tickVal)
 {
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void EquipmentView::render(Bild& rObj)
+void EquipmentView::render(Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
 }
 
-void EquipmentView::doMausEreignis(MausEreignis& me, bool userRet)
+void EquipmentView::doMouseEvent(MouseEvent& me, bool userRet)
 {
-    ZeichnungHintergrund::doMausEreignis(me, userRet);
+    DrawableBackground::doMouseEvent(me, userRet);
 }

FactoryCraft/Equipment.h

@@ -11,21 +11,21 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class EquipmentView : public Framework::ZeichnungHintergrund,
+class EquipmentView : public Framework::DrawableBackground,
                       public NetworkAPIProcessor
 {
 private:
@@ -35,6 +35,6 @@ public:
     EquipmentView(int entityId);
     void api(char* message) override;
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };

FactoryCraft/FactoryClient.cpp

@@ -1,10 +1,10 @@
 #include "FactoryClient.h"
 
-#include <Bild.h>
-#include <Datei.h>
-#include <DateiSystem.h>
-#include <M3Datei.h>
-#include <Textur.h>
+#include <File.h>
+#include <FileSystem.h>
+#include <Image.h>
+#include <M3File.h>
+#include <Texture.h>
 
 #include "Globals.h"
 #include "Load.h"
@@ -12,7 +12,7 @@
 using namespace Network;
 using namespace Framework;
 
-void createDefaultCube(Bildschirm* zScreen)
+void createDefaultCube(Screen* zScreen)
 {
     Model3DData* data = zScreen->zGraphicsApi()->createModel("cube");
     data->setAmbientFactor(0.f);
@@ -163,7 +163,7 @@ void createDefaultCube(Bildschirm* zScreen)
     data->release();
 }
 
-void createGrass(Bildschirm* zScreen)
+void createGrass(Screen* zScreen)
 {
     Model3DData* data = zScreen->zGraphicsApi()->createModel("grass");
     data->setAmbientFactor(0.f);
@@ -288,7 +288,7 @@ void createGrass(Bildschirm* zScreen)
     data->release();
 }
 
-void createFluidCube(Bildschirm* zScreen)
+void createFluidCube(Screen* zScreen)
 {
     Model3DData* data = zScreen->zGraphicsApi()->createModel("fluid");
     data->setAmbientFactor(0.f);
@@ -440,7 +440,7 @@ void createFluidCube(Bildschirm* zScreen)
     data->release();
 }
 
-void createModels(Bildschirm* zScreen)
+void createModels(Screen* zScreen)
 {
     createDefaultCube(zScreen);
     createGrass(zScreen);
@@ -480,29 +480,29 @@ void FactoryClient::loadServerInfo()
     resourcePath.append() << client->getServerIp() << "/"
                           << client->getServerPort() << "/";
     Text tmp = resourcePath + "metainfo.dat";
-    Datei metaInfo(tmp);
+    File metaInfo(tmp);
     Trie<FileInfo*> metaInfos;
     Array<FileInfo*> metaInfoList;
     Array<FileInfo*> downloadOrder;
-    if (metaInfo.existiert())
+    if (metaInfo.exists())
     {
         loadMenu->beginNextStage(
             "reading resource metadata", (int)metaInfo.getSize());
-        metaInfo.open(Datei::Style::lesen);
-        while (!metaInfo.istEnde())
+        metaInfo.open(File::Style::read);
+        while (!metaInfo.isEnd())
         {
             short len = 0;
-            metaInfo.lese((char*)&len, 2);
+            metaInfo.read((char*)&len, 2);
             char* path = new char[len + 1];
-            metaInfo.lese(path, len);
+            metaInfo.read(path, len);
             path[len] = 0;
             FileInfo* fi = new FileInfo();
             fi->path = Text(path);
             fi->size = 0;
-            metaInfo.lese((char*)&fi->year, 4);
-            metaInfo.lese((char*)&fi->month, 4);
-            metaInfo.lese((char*)&fi->day, 4);
-            metaInfo.lese((char*)&fi->seconds, 4);
+            metaInfo.read((char*)&fi->year, 4);
+            metaInfo.read((char*)&fi->month, 4);
+            metaInfo.read((char*)&fi->day, 4);
+            metaInfo.read((char*)&fi->seconds, 4);
             metaInfos.set(path, len, fi);
             delete[] path;
             metaInfoList.add(fi);
@@ -511,21 +511,21 @@ void FactoryClient::loadServerInfo()
         metaInfo.close();
     }
     short len = 0;
-    foreground->getNachricht((char*)&len, 2);
+    foreground->getMessage((char*)&len, 2);
     while (len)
     {
         char* path = new char[len + 1];
-        foreground->getNachricht(path, len);
+        foreground->getMessage(path, len);
         path[len] = 0;
         FileInfo* fi = metaInfos.get(path, len);
         int year;
         int month;
         int day;
         int seconds;
-        foreground->getNachricht((char*)&year, 4);
-        foreground->getNachricht((char*)&month, 4);
-        foreground->getNachricht((char*)&day, 4);
-        foreground->getNachricht((char*)&seconds, 4);
+        foreground->getMessage((char*)&year, 4);
+        foreground->getMessage((char*)&month, 4);
+        foreground->getMessage((char*)&day, 4);
+        foreground->getMessage((char*)&seconds, 4);
         if (!fi || fi->year != year || fi->month != month || fi->day != day
             || fi->seconds != seconds)
         {
@@ -540,37 +540,37 @@ void FactoryClient::loadServerInfo()
             fi->month = month;
             fi->day = day;
             fi->seconds = seconds;
-            foreground->sende("\1", 1);
-            foreground->getNachricht((char*)&fi->size, 8);
+            foreground->send("\1", 1);
+            foreground->getMessage((char*)&fi->size, 8);
             downloadOrder.add(fi);
         }
         else
         {
-            foreground->sende("\0", 1);
+            foreground->send("\0", 1);
         }
         delete[] path;
-        foreground->getNachricht((char*)&len, 2);
+        foreground->getMessage((char*)&len, 2);
     }
     loadMenu->allProgress(1);
     char* buffer = new char[4096];
     loadMenu->beginNextStage(
-        "download updated resouces", downloadOrder.getEintragAnzahl());
+        "download updated resouces", downloadOrder.getEntryCount());
     for (FileInfo* info : downloadOrder)
     {
         loadMenu->beginNextStep(info->path, (int)info->size);
         tmp = resourcePath + info->path;
-        Datei file(tmp);
-        if (!file.existiert())
+        File file(tmp);
+        if (!file.exists())
         {
-            file.erstellen();
+            file.create();
         }
-        file.open(Datei::Style::schreiben);
+        file.open(File::Style::write);
         __int64 remaining = info->size;
         while (remaining > 0)
         {
             int toRead = remaining > 4096 ? 4096 : (int)remaining;
-            foreground->getNachricht(buffer, toRead);
-            file.schreibe(buffer, toRead);
+            foreground->getMessage(buffer, toRead);
+            file.write(buffer, toRead);
             remaining -= toRead;
             loadMenu->stepProgress(toRead);
         }
@@ -580,52 +580,51 @@ void FactoryClient::loadServerInfo()
     delete[] buffer;
     loadMenu->allProgress(1);
     loadMenu->beginNextStage(
-        "writing resource metadata", metaInfoList.getEintragAnzahl());
-    if (!metaInfo.existiert())
+        "writing resource metadata", metaInfoList.getEntryCount());
+    if (!metaInfo.exists())
     {
-        metaInfo.erstellen();
+        metaInfo.create();
     }
-    metaInfo.open(Datei::Style::schreiben);
+    metaInfo.open(File::Style::write);
     for (FileInfo* info : metaInfoList)
     {
         short len = (short)info->path.getLength();
-        metaInfo.schreibe((char*)&len, 2);
-        metaInfo.schreibe(info->path.getText(), len);
-        metaInfo.schreibe((char*)&info->year, 4);
-        metaInfo.schreibe((char*)&info->month, 4);
-        metaInfo.schreibe((char*)&info->day, 4);
-        metaInfo.schreibe((char*)&info->seconds, 4);
+        metaInfo.write((char*)&len, 2);
+        metaInfo.write(info->path.getText(), len);
+        metaInfo.write((char*)&info->year, 4);
+        metaInfo.write((char*)&info->month, 4);
+        metaInfo.write((char*)&info->day, 4);
+        metaInfo.write((char*)&info->seconds, 4);
         loadMenu->stageProgress(1);
     }
     metaInfo.close();
     loadMenu->allProgress(1);
-    loadMenu->beginNextStage(
-        "loading resources", metaInfoList.getEintragAnzahl());
+    loadMenu->beginNextStage("loading resources", metaInfoList.getEntryCount());
     for (FileInfo* info : metaInfoList)
     {
         if (info->path.endsWith(".ltdb"))
         {
-            LTDBDatei dat;
-            dat.setDatei(new Text(resourcePath + info->path));
-            dat.leseDaten(0);
-            loadMenu->beginNextStep(info->path, dat.getBildAnzahl());
-            for (Text* name : *dat.zBildListe())
+            LTDBFile dat;
+            dat.setFile(new Text(resourcePath + info->path));
+            dat.readData(0);
+            loadMenu->beginNextStep(info->path, dat.getImageCount());
+            for (Text* name : *dat.zImageListe())
             {
-                Bild* b = dat.laden(0, new Text(*name));
+                Image* b = dat.load(0, new Text(*name));
                 uiFactory.initParam.bildschirm->zGraphicsApi()
-                    ->createOrGetTextur(info->path + "/" + *name, b)
+                    ->createOrGetTexture(info->path + "/" + *name, b)
                     ->release();
                 loadMenu->stepProgress(1);
             }
         }
         else if (info->path.endsWith(".m3"))
         {
-            M3Datei dat(resourcePath + info->path);
-            dat.leseDaten();
-            loadMenu->beginNextStep(info->path, dat.getModelAnzahl());
-            for (int i = 0; i < dat.getModelAnzahl(); i++)
+            M3File dat(resourcePath + info->path);
+            dat.readData();
+            loadMenu->beginNextStep(info->path, dat.getModelCount());
+            for (int i = 0; i < dat.getModelCount(); i++)
             {
-                Model3DData* d = dat.ladeModel(dat.zModelName(i)->getText(),
+                Model3DData* d = dat.loadModel(dat.zModelName(i)->getText(),
                     uiFactory.initParam.bildschirm->zGraphicsApi(),
                     info->path + "/" + *dat.zModelName(i));
                 d->release();
@@ -648,22 +647,22 @@ void FactoryClient::loadServerInfo()
     for (int i = 0; i < entityTypeCount; i++)
         entityTypes[i]->release();
     delete[] entityTypes;
-    foregroundReader->lese((char*)&blockTypeCount, 4);
+    foregroundReader->read((char*)&blockTypeCount, 4);
     blockTypes = new BlockType*[blockTypeCount];
     for (int i = 0; i < blockTypeCount; i++)
     {
         int id;
-        foregroundReader->lese((char*)&id, 4);
+        foregroundReader->read((char*)&id, 4);
         bool needsInstance;
-        foregroundReader->lese((char*)&needsInstance, 1);
+        foregroundReader->read((char*)&needsInstance, 1);
         bool needsSubscription;
-        foregroundReader->lese((char*)&needsSubscription, 1);
+        foregroundReader->read((char*)&needsSubscription, 1);
         bool fluid;
-        foregroundReader->lese((char*)&fluid, 1);
+        foregroundReader->read((char*)&fluid, 1);
         char maxFlowDistance = 0;
-        if (fluid) foregroundReader->lese((char*)&maxFlowDistance, 1);
+        if (fluid) foregroundReader->read((char*)&maxFlowDistance, 1);
         int maxHp;
-        foregroundReader->lese((char*)&maxHp, 4);
+        foregroundReader->read((char*)&maxHp, 4);
         blockTypes[i] = new BlockType(id,
             needsInstance,
             ModelInfo(foregroundReader),
@@ -673,21 +672,21 @@ void FactoryClient::loadServerInfo()
             maxFlowDistance);
     }
     loadMenu->allProgress(1);
-    foregroundReader->lese((char*)&itemTypeCount, 4);
+    foregroundReader->read((char*)&itemTypeCount, 4);
     itemTypes = new ItemType*[itemTypeCount];
     for (int i = 0; i < itemTypeCount; i++)
     {
         int id;
-        foregroundReader->lese((char*)&id, 4);
+        foregroundReader->read((char*)&id, 4);
         char len;
-        foregroundReader->lese((char*)&len, 1);
+        foregroundReader->read((char*)&len, 1);
         char* name = new char[len + 1];
-        foregroundReader->lese(name, len);
+        foregroundReader->read(name, len);
         name[len] = 0;
         short tlen;
-        foregroundReader->lese((char*)&tlen, 2);
+        foregroundReader->read((char*)&tlen, 2);
         char* tooltipUIML = new char[tlen + 1];
-        foregroundReader->lese(tooltipUIML, tlen);
+        foregroundReader->read(tooltipUIML, tlen);
         tooltipUIML[tlen] = 0;
         itemTypes[i] = new ItemType(
             id, ModelInfo(foregroundReader), Text(name), Text(tooltipUIML));
@@ -695,28 +694,28 @@ void FactoryClient::loadServerInfo()
         delete[] tooltipUIML;
     }
     loadMenu->allProgress(1);
-    foregroundReader->lese((char*)&entityTypeCount, 4);
+    foregroundReader->read((char*)&entityTypeCount, 4);
     entityTypes = new EntityType*[entityTypeCount];
     for (int i = 0; i < entityTypeCount; i++)
     {
         int id;
-        foregroundReader->lese((char*)&id, 4);
+        foregroundReader->read((char*)&id, 4);
         entityTypes[i] = new EntityType(id, ModelInfo(foregroundReader));
     }
     loadMenu->allProgress(1);
     loadMenu->beginNextStage("rendering item icons", itemTypeCount);
-    Kam3D* kam = new Kam3D();
-    Welt3D* w = new Welt3D();
+    Cam3D* kam = new Cam3D();
+    World3D* w = new World3D();
     w->addDiffuseLight(DiffuseLight{
         Vec3<float>(0.5f, 0.5f, -1.f), Vec3<float>(1.f, 1.f, 1.f)});
-    kam->setWelt(w);
-    kam->setBildschirmPosition(0, 0);
-    kam->setBildschirmSize(50, 50);
+    kam->setWorld(w);
+    kam->setScreenPosition(0, 0);
+    kam->setScreenSize(50, 50);
     kam->setPosition(Vec3<float>(0, 0, 0));
     kam->setRotation(
         {(float)PI / 2.f, 0.f, std::atan2(0.f, -1.f) + (float)PI / 2});
-    Bild* b = new Bild();
-    b->neuBild(50, 50, 0);
+    Image* b = new Image();
+    b->newImage(50, 50, 0);
     for (int i = 0; i < itemTypeCount; i++)
     {
         Model3D* mdl = new Model3D();
@@ -730,29 +729,29 @@ void FactoryClient::loadServerInfo()
                 MAX(abs(min.z), abs(max.z)));
             kam->setPosition(Vec3<float>(maxX * 3.5f, 0.f, 0.f));
         }
-        mdl->setModelDaten(data);
+        mdl->setModelData(data);
         mdl->setModelTextur(itemTypes[i]->getItemTextur());
         mdl->setPosition(Vec3<float>(0.f, 0.f, 0.f));
-        mdl->setDrehung(0.25f, 0.25f, 0.55f);
+        mdl->setRotation(0.25f, 0.25f, 0.55f);
         mdl->setAmbientFactor(0.8f);
         mdl->setDiffusFactor(0.1f);
         mdl->setSpecularFactor(0.1f);
         mdl->setSize(itemTypes[i]->getSize());
-        w->addZeichnung(mdl);
+        w->addDrawable(mdl);
         w->tick(0);
-        window->zBildschirm()->lock();
-        DX11Textur* t = (DX11Textur*)window->zBildschirm()
-                            ->zGraphicsApi()
-                            ->createOrGetTextur(
-                                Text("rendered/items/") + itemTypes[i]->getId(),
-                                dynamic_cast<Bild*>(b->getThis()));
-        window->zBildschirm()->zGraphicsApi()->renderKamera(kam, t);
-        Bild* result = new Bild();
+        window->zScreen()->lock();
+        DX11Texture* t = (DX11Texture*)window->zScreen()
+                             ->zGraphicsApi()
+                             ->createOrGetTexture(Text("rendered/items/")
+                                                      + itemTypes[i]->getId(),
+                                 dynamic_cast<Image*>(b->getThis()));
+        window->zScreen()->zGraphicsApi()->renderKamera(kam, t);
+        Image* result = new Image();
         t->copyToImage(result);
         itemTypes[i]->setBild(result);
         t->release();
-        window->zBildschirm()->unlock();
-        w->removeZeichnung(mdl);
+        window->zScreen()->unlock();
+        w->removeDrawable(mdl);
         loadMenu->stageProgress(1);
     }
     b->release();
@@ -763,41 +762,41 @@ void FactoryClient::loadServerInfo()
 bool FactoryClient::connect(Text ip, unsigned short sslPort)
 {
     if (client) disconnect();
-    client = new SSLKlient();
-    if (!client->verbinde(sslPort, ip)) return false;
+    client = new SSLClient();
+    if (!client->connect(sslPort, ip)) return false;
     char c;
-    while (client->hatNachricht(1))
-        client->getNachricht(&c, 1);
+    while (client->hasMessage(1))
+        client->getMessage(&c, 1);
     this->ip = ip;
     return 1;
 }
 
 int FactoryClient::ping()
 {
-    ZeitMesser zm;
-    zm.messungStart();
-    if (!client->sende("\3", 1)) return -1;
+    Timer zm;
+    zm.measureStart();
+    if (!client->send("\3", 1)) return -1;
     char c;
-    client->getNachricht(&c, 1);
-    zm.messungEnde();
+    client->getMessage(&c, 1);
+    zm.measureEnd();
     return (int)(zm.getSekunden() * 1000);
 }
 
 int FactoryClient::status(Framework::Text name, Framework::Text secret)
 {
-    if (!client->sende("\4", 1)) return 404;
+    if (!client->send("\4", 1)) return 404;
     char c;
-    client->getNachricht(&c, 1);
+    client->getMessage(&c, 1);
     if (c == 1)
     {
         char len = (char)name.getLength();
-        client->sende(&len, 1);
-        client->sende(name, len);
+        client->send(&len, 1);
+        client->send(name, len);
         short sLen = (short)secret.getLength();
-        client->sende((char*)&sLen, 2);
-        client->sende(secret, sLen);
+        client->send((char*)&sLen, 2);
+        client->send(secret, sLen);
         char res;
-        client->getNachricht(&res, 1);
+        client->getMessage(&res, 1);
         if (res == 1) return 200;
         if (res == 0) return 403;
     }
@@ -807,48 +806,48 @@ int FactoryClient::status(Framework::Text name, Framework::Text secret)
 int FactoryClient::join(
     Framework::Text name, Framework::Text& secret, unsigned short port)
 {
-    client->sende("\1", 1);
+    client->send("\1", 1);
     char len = (char)name.getLength();
-    client->sende(&len, 1);
-    client->sende(name, len);
+    client->send(&len, 1);
+    client->send(name, len);
     short sLen = (short)secret.getLength();
-    client->sende((char*)&sLen, 2);
-    client->sende(secret, sLen);
+    client->send((char*)&sLen, 2);
+    client->send(secret, sLen);
     char res;
-    client->getNachricht(&res, 1);
+    client->getMessage(&res, 1);
     if (res == 1 || res == 2)
     {
         if (res == 2)
         {
-            client->getNachricht((char*)&sLen, 2);
+            client->getMessage((char*)&sLen, 2);
             char* buffer = new char[sLen + 1];
-            client->getNachricht(buffer, sLen);
+            client->getMessage(buffer, sLen);
             buffer[sLen] = 0;
             secret = buffer;
             delete[] buffer;
         }
         short keyLen;
-        client->getNachricht((char*)&keyLen, 2);
+        client->getMessage((char*)&keyLen, 2);
         char* key = new char[keyLen];
-        client->getNachricht(key, keyLen);
-        foreground = new Klient();
-        if (!foreground->verbinde(port, ip))
+        client->getMessage(key, keyLen);
+        foreground = new Client();
+        if (!foreground->connect(port, ip))
         {
             delete[] key;
             return false;
         }
-        if (!foreground->sende((char*)&keyLen, 2))
+        if (!foreground->send((char*)&keyLen, 2))
         {
             delete[] key;
             return false;
         }
-        if (!foreground->sende(key, keyLen))
+        if (!foreground->send(key, keyLen))
         {
             delete[] key;
             return false;
         }
-        background = new Klient();
-        if (!background->verbinde(port, ip))
+        background = new Client();
+        if (!background->connect(port, ip))
         {
             delete[] key;
             foreground->release();
@@ -857,7 +856,7 @@ int FactoryClient::join(
             background = 0;
             return false;
         }
-        if (!background->sende((char*)&keyLen, 2))
+        if (!background->send((char*)&keyLen, 2))
         {
             delete[] key;
             foreground->release();
@@ -866,7 +865,7 @@ int FactoryClient::join(
             background = 0;
             return false;
         }
-        if (!background->sende(key, keyLen))
+        if (!background->send(key, keyLen))
         {
             delete[] key;
             foreground->release();
@@ -877,21 +876,21 @@ int FactoryClient::join(
         }
         delete[] key;
         bool bg = 0;
-        if (!foreground->sende((char*)&bg, 1))
+        if (!foreground->send((char*)&bg, 1))
         {
             delete[] key;
             return 201;
         }
         foregroundReader = new NetworkReader(foreground);
         bg = 1;
-        if (!background->sende((char*)&bg, 1)) return 201;
+        if (!background->send((char*)&bg, 1)) return 201;
         backgroundReader = new NetworkReader(background);
         char res;
-        foregroundReader->lese(&res, 1);
+        foregroundReader->read(&res, 1);
         if (res != 1) return 403;
-        backgroundReader->lese(&res, 1);
+        backgroundReader->read(&res, 1);
         if (res != 1) return 403;
-        client->trenne();
+        client->disconnect();
         loadServerInfo();
         return 200;
     }
@@ -907,8 +906,8 @@ void FactoryClient::disconnect()
         NetworkReader* bgReader = backgroundReader;
         backgroundReader = 0;
         foregroundReader = 0;
-        if (foreground) foreground->trenne();
-        if (background) background->trenne();
+        if (foreground) foreground->disconnect();
+        if (background) background->disconnect();
         while (fgReaderUsage > 0 || bgReaderUsage > 0)
             Sleep(100);
         delete fgReader;
@@ -927,7 +926,7 @@ NetworkReader* FactoryClient::getNextForegroundMessage()
     fgReaderUsage++;
     if (!foreground) return 0;
     if (!foreground->isConnected()) return 0;
-    if (!foreground->hatNachricht(0)) return 0;
+    if (!foreground->hasMessage(0)) return 0;
     return foregroundReader;
 }
 
@@ -936,7 +935,7 @@ NetworkReader* FactoryClient::getNextBackgroundMessage()
     bgReaderUsage++;
     if (!background) return 0;
     if (!background->isConnected()) return 0;
-    if (!background->hatNachricht(0)) return 0;
+    if (!background->hasMessage(0)) return 0;
     return backgroundReader;
 }
 
@@ -953,10 +952,10 @@ void FactoryClient::sendPlayerAction(const char* data, unsigned short length)
     if (!foreground) return;
     cs.lock();
     length += 1;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 2;
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)data, length - 1);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)data, length - 1);
     cs.unlock();
 }
 
@@ -965,13 +964,13 @@ void FactoryClient::sendPlayerFaceDirection(Vec3<float> dir)
     if (!foreground) return;
     cs.lock();
     short length = 14;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 2; // player message
-    foreground->sende(&msgId, 1);
-    foreground->sende(&msgId, 1); // set face direction
-    foreground->sende((char*)&dir.x, 4);
-    foreground->sende((char*)&dir.y, 4);
-    foreground->sende((char*)&dir.z, 4);
+    foreground->send(&msgId, 1);
+    foreground->send(&msgId, 1); // set face direction
+    foreground->send((char*)&dir.x, 4);
+    foreground->send((char*)&dir.y, 4);
+    foreground->send((char*)&dir.z, 4);
     cs.unlock();
 }
 
@@ -980,12 +979,12 @@ void FactoryClient::sendPlayerMovement(int flags)
     if (!foreground) return;
     cs.lock();
     short length = 6;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 2; // player message
-    foreground->sende(&msgId, 1);
+    foreground->send(&msgId, 1);
     msgId = 10; // set movement
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&flags, 4);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&flags, 4);
     cs.unlock();
 }
 
@@ -995,11 +994,11 @@ void FactoryClient::entityAPIRequest(
     if (!foreground) return;
     cs.lock();
     length += 5;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 3;
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&entityId, 4);
-    foreground->sende(message, length - 5);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&entityId, 4);
+    foreground->send(message, length - 5);
     cs.unlock();
 }
 
@@ -1009,14 +1008,14 @@ void FactoryClient::blockAPIRequest(
     if (!foreground) return;
     cs.lock();
     length += 14;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 1;
-    foreground->sende(&msgId, 1);
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&pos.x, 4);
-    foreground->sende((char*)&pos.y, 4);
-    foreground->sende((char*)&pos.z, 4);
-    foreground->sende(message, length - 14);
+    foreground->send(&msgId, 1);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&pos.x, 4);
+    foreground->send((char*)&pos.y, 4);
+    foreground->send((char*)&pos.z, 4);
+    foreground->send(message, length - 14);
     cs.unlock();
 }
 
@@ -1026,31 +1025,31 @@ void FactoryClient::componentAPIRequest(
     if (!foreground) return;
     cs.lock();
     short sum = length + addrLen * 4 + (addrLen > 2 ? 3 : 2);
-    foreground->sende((char*)&sum, 2);
+    foreground->send((char*)&sum, 2);
     if (addrLen > 2)
     {
         char msgId = 7; // dimension request
-        foreground->sende(&msgId, 1);
-        foreground->sende((char*)&address[0], 4); // dimension id
-        msgId = 1;                                // block request
-        foreground->sende(&msgId, 1);
-        foreground->sende((char*)&address[1], 4); // position x
-        foreground->sende((char*)&address[2], 4); // position y
-        foreground->sende((char*)&address[3], 4); // position z
-        msgId = 2;                                // component request
-        foreground->sende(&msgId, 1);
-        foreground->sende((char*)&address[4], 4); // component index
+        foreground->send(&msgId, 1);
+        foreground->send((char*)&address[0], 4); // dimension id
+        msgId = 1;                               // block request
+        foreground->send(&msgId, 1);
+        foreground->send((char*)&address[1], 4); // position x
+        foreground->send((char*)&address[2], 4); // position y
+        foreground->send((char*)&address[3], 4); // position z
+        msgId = 2;                               // component request
+        foreground->send(&msgId, 1);
+        foreground->send((char*)&address[4], 4); // component index
     }
     else
     {
         char msgId = 3; // entity request
-        foreground->sende(&msgId, 1);
-        foreground->sende((char*)&address[0], 4); // entity id
-        msgId = 2;                                // component request
-        foreground->sende(&msgId, 1);
-        foreground->sende((char*)&address[1], 4); // component index
+        foreground->send(&msgId, 1);
+        foreground->send((char*)&address[0], 4); // entity id
+        msgId = 2;                               // component request
+        foreground->send(&msgId, 1);
+        foreground->send((char*)&address[1], 4); // component index
     }
-    foreground->sende(message, length);
+    foreground->send(message, length);
     cs.unlock();
 }
 
@@ -1060,33 +1059,33 @@ void FactoryClient::blockAPIRequest(
     if (!foreground) return;
     cs.lock();
     length += 18;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 7;
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&dimensionId, 4);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&dimensionId, 4);
     msgId = 1;
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&pos.x, 4);
-    foreground->sende((char*)&pos.y, 4);
-    foreground->sende((char*)&pos.z, 4);
-    foreground->sende(message, length - 18);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&pos.x, 4);
+    foreground->send((char*)&pos.y, 4);
+    foreground->send((char*)&pos.z, 4);
+    foreground->send(message, length - 18);
     cs.unlock();
 }
 
 void FactoryClient::chunkAPIRequest(
-    Punkt center, const char* message, unsigned short length)
+    Point center, const char* message, unsigned short length)
 {
     if (!foreground) return;
     length += 10;
     cs.lock();
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char type = 1;
-    foreground->sende(&type, 1);
+    foreground->send(&type, 1);
     type = 0;
-    foreground->sende(&type, 1);
-    foreground->sende((char*)&center.x, 4);
-    foreground->sende((char*)&center.y, 4);
-    foreground->sende(message, length - 10);
+    foreground->send(&type, 1);
+    foreground->send((char*)&center.x, 4);
+    foreground->send((char*)&center.y, 4);
+    foreground->send(message, length - 10);
     cs.unlock();
 }
 
@@ -1096,10 +1095,10 @@ void FactoryClient::dimensionAPIRequest(
     if (!foreground) return;
     length += 1;
     cs.lock();
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char type = 1;
-    foreground->sende(&type, 1);
-    foreground->sende(message, length - 1);
+    foreground->send(&type, 1);
+    foreground->send(message, length - 1);
     cs.unlock();
 }
 
@@ -1111,25 +1110,25 @@ void FactoryClient::inventoryAPIRequest(
     if (!foreground) return;
     cs.lock();
     length += target.isA() ? 6 : 18;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 4;
-    foreground->sende(&msgId, 1);
+    foreground->send(&msgId, 1);
     bool isEntity = target.isA();
-    foreground->sende((char*)&isEntity, 1);
+    foreground->send((char*)&isEntity, 1);
     if (target.isA())
     {
         int id = target.getA();
-        foreground->sende((char*)&id, 4);
+        foreground->send((char*)&id, 4);
     }
     else
     {
         for (int i = 0; i < 4; i++)
         {
             int v = target.getB()[i];
-            foreground->sende((char*)&v, 4);
+            foreground->send((char*)&v, 4);
         }
     }
-    foreground->sende(message, length - (target.isA() ? 6 : 18));
+    foreground->send(message, length - (target.isA() ? 6 : 18));
     cs.unlock();
 }
 
@@ -1139,13 +1138,13 @@ void FactoryClient::uiRequest(
     if (!foreground) return;
     short nameLen = (short)dialogId.getLength();
     length += nameLen + 3;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     cs.lock();
     char msgId = 8;
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&nameLen, 2);
-    foreground->sende(dialogId, nameLen);
-    foreground->sende(message, length - nameLen - 3);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&nameLen, 2);
+    foreground->send(dialogId, nameLen);
+    foreground->send(message, length - nameLen - 3);
     cs.unlock();
 }
 
@@ -1154,10 +1153,10 @@ void FactoryClient::craftingUIMLRequest(int itemTypeId)
     if (!foreground) return;
     cs.lock();
     short length = 5;
-    foreground->sende((char*)&length, 2);
+    foreground->send((char*)&length, 2);
     char msgId = 5;
-    foreground->sende(&msgId, 1);
-    foreground->sende((char*)&itemTypeId, 4);
+    foreground->send(&msgId, 1);
+    foreground->send((char*)&itemTypeId, 4);
     cs.unlock();
 }
 
@@ -1166,14 +1165,14 @@ void FactoryClient::sendChatMessage(Framework::Text message)
     if (!background) return;
     cs.lock();
     short length = message.getLength() + 4;
-    background->sende((char*)&length, 2);
+    background->send((char*)&length, 2);
     char msgId = 6;
-    background->sende(&msgId, 1);
+    background->send(&msgId, 1);
     msgId = 0;
-    background->sende(&msgId, 1);
+    background->send(&msgId, 1);
     length = message.getLength();
-    background->sende((char*)&length, 2);
-    background->sende(message.getText(), message.getLength());
+    background->send((char*)&length, 2);
+    background->send(message.getText(), message.getLength());
     cs.unlock();
 }
 
@@ -1182,10 +1181,10 @@ void FactoryClient::chatAPIRequest(const char* data, unsigned short length)
     if (!background) return;
     cs.lock();
     short totalLength = length + 1;
-    background->sende((char*)&totalLength, 2);
+    background->send((char*)&totalLength, 2);
     char msgId = 6;
-    background->sende(&msgId, 1);
-    background->sende(data, length);
+    background->send(&msgId, 1);
+    background->send(data, length);
     cs.unlock();
 }
 

FactoryCraft/FactoryClient.h

@@ -2,9 +2,9 @@
 
 #include <Critical.h>
 #include <Either.h>
-#include <Klient.h>
+#include <Client.h>
 #include <Network.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Text.h>
 #include <Thread.h>
 #include <VecN.h>
@@ -14,9 +14,9 @@
 class FactoryClient : public Framework::ReferenceCounter
 {
 private:
-    Network::SSLKlient* client;
-    Network::Klient* foreground;
-    Network::Klient* background;
+    Network::SSLClient* client;
+    Network::Client* foreground;
+    Network::Client* background;
     Network::NetworkReader* foregroundReader;
     Network::NetworkReader* backgroundReader;
     Framework::Critical cs;
@@ -53,7 +53,7 @@ public:
         const char* message,
         unsigned short length);
     void chunkAPIRequest(
-        Framework::Punkt center, const char* message, unsigned short length);
+        Framework::Point center, const char* message, unsigned short length);
     void dimensionAPIRequest(const char* message, unsigned short length);
     void inventoryAPIRequest(
         Framework::Either<int, Framework::VecN<int, 4>> target,

FactoryCraft/FactoryCraft.vcxproj

@@ -201,7 +201,7 @@ copy "..\..\..\..\..\Allgemein\Network\x64\Release\Network.dll" "network.dll"</C
     <ClCompile Include="FactoryCraftModel.cpp" />
     <ClCompile Include="Game.cpp" />
     <ClCompile Include="Globals.cpp" />
-    <ClCompile Include="Initialisierung.cpp" />
+    <ClCompile Include="Initialization.cpp" />
     <ClCompile Include="InventoryView.cpp" />
     <ClCompile Include="ItemBar.cpp" />
     <ClCompile Include="ItemList.cpp" />
@@ -263,7 +263,7 @@ copy "..\..\..\..\..\Allgemein\Network\x64\Release\Network.dll" "network.dll"</C
     <ClInclude Include="FactoryCraftModel.h" />
     <ClInclude Include="Game.h" />
     <ClInclude Include="Globals.h" />
-    <ClInclude Include="Initialisierung.h" />
+    <ClInclude Include="Initialization.h" />
     <ClInclude Include="InventoryView.h" />
     <ClInclude Include="ItemBar.h" />
     <ClInclude Include="ItemList.h" />

FactoryCraft/FactoryCraft.vcxproj.filters

@@ -88,7 +88,7 @@
     <ClCompile Include="Globals.cpp">
       <Filter>static</Filter>
     </ClCompile>
-    <ClCompile Include="Initialisierung.cpp">
+    <ClCompile Include="Initialization.cpp">
       <Filter>static</Filter>
     </ClCompile>
     <ClCompile Include="BlockType.cpp">
@@ -273,7 +273,7 @@
     <ClInclude Include="Globals.h">
       <Filter>static</Filter>
     </ClInclude>
-    <ClInclude Include="Initialisierung.h">
+    <ClInclude Include="Initialization.h">
       <Filter>static</Filter>
     </ClInclude>
     <ClInclude Include="BlockType.h">

FactoryCraft/FactoryCraftModel.cpp

@@ -15,7 +15,7 @@ FactoryCraftModel::FactoryCraftModel()
     visible = 1;
     destroyedState = 0;
     breakTextur
-        = uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTextur(
+        = uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTexture(
             "blocks.ltdb/crack.png", 0);
     effectAlpha = 0;
     memset(averageLight, 0, 8);
@@ -46,7 +46,7 @@ void FactoryCraftModel::beforeRender(Framework::GraphicsApi* api,
         *(int*)buffer
             = vertexLightBufferCount == 0 ? 1 : vertexLightBufferCount;
         *(float*)(buffer + 4) = World::INSTANCE->getDayLightFactor();
-        zVertexShader->füllConstBuffer(
+        zVertexShader->fillConstBuffer(
             buffer, cApi->getVertexShaderLightBufferIndex(), 8);
         if (vertexLightBuffer)
         {
@@ -57,14 +57,14 @@ void FactoryCraftModel::beforeRender(Framework::GraphicsApi* api,
             World::INSTANCE->zFallbackVertexLightBuffer()->setData(
                 averageLight);
             World::INSTANCE->zFallbackVertexLightBuffer()->setChanged();
-            World::INSTANCE->zFallbackVertexLightBuffer()->copieren(8);
+            World::INSTANCE->zFallbackVertexLightBuffer()->copyToGPU(8);
             cApi->setVertexLightBuffer(
                 World::INSTANCE->zFallbackVertexLightBuffer());
         }
         if (destroyedState > 0 && effectAlpha)
         {
             TexturEffect e = {1, 1.f + destroyedState};
-            zPixelShader->füllConstBuffer((char*)&e, 3, sizeof(TexturEffect));
+            zPixelShader->fillConstBuffer((char*)&e, 3, sizeof(TexturEffect));
         }
     }
 }
@@ -80,7 +80,7 @@ void FactoryCraftModel::afterRender(Framework::GraphicsApi* api,
         char buffer[8];
         *(int*)buffer = 0;
         *(float*)(buffer + 4) = World::INSTANCE->getDayLightFactor();
-        zVertexShader->füllConstBuffer(
+        zVertexShader->fillConstBuffer(
             buffer, cApi->getVertexShaderLightBufferIndex(), 8);
     }
 }
@@ -100,7 +100,7 @@ void FactoryCraftModel::setVertexLightBuffer(__int64* data, int vertexCount)
     vertexLightBufferCount = vertexCount;
     vertexLightBuffer->setData(data);
     vertexLightBuffer->setLength(vertexCount * 8);
-    vertexLightBuffer->copieren();
+    vertexLightBuffer->copyToGPU();
 }
 
 __int64* FactoryCraftModel::zLightBuffer()
@@ -116,7 +116,7 @@ void FactoryCraftModel::copyLightToGPU()
 {
     if (vertexLightBuffer)
     {
-        vertexLightBuffer->copieren();
+        vertexLightBuffer->copyToGPU();
     }
 }
 
@@ -140,7 +140,7 @@ bool FactoryCraftModel::needRenderPolygon(int index)
     return visible;
 }
 
-Textur* FactoryCraftModel::zEffectTextur()
+Texture* FactoryCraftModel::zEffectTexture()
 {
     return destroyedState > 0 ? breakTextur : 0;
 }

FactoryCraft/FactoryCraftModel.h

@@ -3,7 +3,7 @@
 #include <DXBuffer.h>
 #include <GraphicsApi.h>
 #include <Model3D.h>
-#include <Textur.h>
+#include <Texture.h>
 
 class FactoryCraftModel : public Framework::Model3D
 {
@@ -13,7 +13,7 @@ private:
     int vertexLightBufferCount;
     bool visible;
     float destroyedState;
-    Framework::Textur* breakTextur;
+    Framework::Texture* breakTextur;
     bool effectAlpha;
     unsigned char averageLight[8];
 
@@ -35,7 +35,7 @@ public:
     void setDestroyedState(float percentage);
     void setUseEffectAlpha(bool useAlpha);
     bool needRenderPolygon(int index) override;
-    Framework::Textur* zEffectTextur() override;
+    Framework::Texture* zEffectTexture() override;
     float getEffectPercentage() override;
     void setAverageLight(unsigned char light[3]);
 };

FactoryCraft/Game.cpp

@@ -1,94 +1,94 @@
 #include "Game.h"
 
 #include <AsynchronCall.h>
-#include <Bildschirm.h>
-#include <DateiSystem.h>
+#include <FileSystem.h>
+#include <Screen.h>
 
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 #include "ItemBar.h"
 #include "StatusBars.h"
 
-Game::Game(Bildschirm* zScreen)
+Game::Game(Screen* zScreen)
     : Menu(zScreen),
       recipieVisible(0),
       itemListContainer(0)
 {
-    LTDBDatei dat;
-    dat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    dat.leseDaten(0);
-    Bild* search = dat.laden(0, new Text("search.png"));
-    searchIcon = new BildZ();
-    searchIcon->setBildZ(search);
-    searchIcon->setStyle(
-        BildZ::Style::Sichtbar | BildZ::Style::Alpha | BildZ::Style::Rahmen);
+    LTDBFile dat;
+    dat.setFile(new Text("data/images/gui_icons.ltdb"));
+    dat.readData(0);
+    Image* search = dat.load(0, new Text("search.png"));
+    searchIcon = new ImageView();
+    searchIcon->setImageZ(search);
+    searchIcon->setStyle(ImageView::Style::Visible | ImageView::Style::Alpha
+                         | ImageView::Style::Border);
     searchIcon->setSize(20, 20);
-    searchIcon->setRahmenFarbe(0xFF6d6d6d);
-    elements.add(new ScreenCenter());
+    searchIcon->setBorderColor(0xFF6d6d6d);
+    elements.add(new ::ScreenCenter());
     inventoryDragController = new DragController<InventoryDragSource, int>();
-    logout = initKnopf(10, 10, 200, 20, Knopf::Style::Normal, "Verlassen");
-    logout->setMausEreignis([this, zScreen](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    logout = initButton(10, 10, 200, 20, Button::Style::Normal, "Verlassen");
+    logout->setMouseEvent([this, zScreen](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
-            logout->removeStyle(Knopf::Style::Erlaubt);
+            logout->removeStyle(Button::Style::Allowed);
             zScreen->postAction([this, zScreen]() {
                 World::INSTANCE->zClient()->leaveGame();
-                logout->addStyle(Knopf::Style::Erlaubt);
+                logout->addStyle(Button::Style::Allowed);
             });
         }
         return 1;
     });
     elements.add(logout);
-    debug = initTextFeld(10,
+    debug = initTextField(10,
         40,
         500,
         250,
-        TextFeld::Style::Text | TextFeld::Style::Mehrzeilig,
+        TextField::Style::Text | TextField::Style::Multiline,
         "");
     elements.add(debug);
     guiView = new UIMLView("<v/>", uiFactory);
     guiView->addKnownElement(new ItemBarElement());
     guiView->addKnownElement(new StatusBarsElement());
-    guiView->setStyle(UIMLView::Style::Sichtbar);
-    guiView->setSize(window->zBildschirm()->getBackBufferSize());
+    guiView->setStyle(UIMLView::Style::Visible);
+    guiView->setSize(window->zScreen()->getBackBufferSize());
     elements.add(guiView);
     targetUIMLView = new UIMLView("<v/>", uiFactory);
     targetUIMLView->setStyle(
-        UIMLView::Style::Hintergrund | UIMLView::Style::HAlpha);
-    targetUIMLView->setHintergrundFarbe(0xA0000000);
+        UIMLView::Style::Background | UIMLView::Style::BAlpha);
+    targetUIMLView->setBackgroundColor(0xA0000000);
     elements.add(targetUIMLView);
 
-    filter = initTextFeld(zScreen->getBackBufferSize().x / 2 - 200,
+    filter = initTextField(zScreen->getBackBufferSize().x / 2 - 200,
         zScreen->getBackBufferSize().y - 200,
         400,
         20,
-        Framework::TextFeld::Style::TextFeld,
+        Framework::TextField::Style::TextField,
         "");
     searchIcon->setPosition(
-        filter->getX() + filter->getBreite() - 20, filter->getY());
+        filter->getX() + filter->getWidth() - 20, filter->getY());
 
     chat = new Chat();
     elements.add(chat);
 
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    chatButton = uiFactory.createKnopf(uiFactory.initParam);
-    chatButton->setToolTipText("Chat", zScreen, uiFactory.initParam.schrift);
-    chatButton->setAlphaFeldFarbe(0x5F337AB7);
+    chatButton = uiFactory.createButton(uiFactory.initParam);
+    chatButton->setToolTipText("Chat", zScreen, uiFactory.initParam.font);
+    chatButton->setAlphaFieldColor(0x5F337AB7);
     chatButton->setSize(40, 40);
     chatButton->setPosition(5, zScreen->getBackBufferSize().y - 45);
-    chatButton->addStyle(Framework::Knopf::Style::HBild
-                         | Framework::Knopf::Style::HAlpha
-                         | Framework::Knopf::Style::Hintergrund);
-    chatButton->setHintergrundBildZ(iconsDat.laden(0, new Text("chat.png")));
-    chatButton->setMausEreignis(
-        [this](void* p, void* o, Framework::MausEreignis me) {
-            if (me.id == ME_RLinks)
+    chatButton->addStyle(Framework::Button::Style::BImage
+                         | Framework::Button::Style::BAlpha
+                         | Framework::Button::Style::Background);
+    chatButton->setBackgroundImageZ(iconsDat.load(0, new Text("chat.png")));
+    chatButton->setMouseEvent(
+        [this](void* p, void* o, Framework::MouseEvent me) {
+            if (me.id == ME_RLeft)
             {
-                chat->addStyle(Fenster::Style::Sichtbar);
-                chatButton->removeStyle(Knopf::Style::Sichtbar);
+                chat->addStyle(Window::Style::Visible);
+                chatButton->removeStyle(Button::Style::Visible);
             }
             return 1;
         });
@@ -154,7 +154,7 @@ void Game::api(char* data)
             dialogCs.lock();
             for (UIMLDialog* dialog : dialogs)
             {
-                if (dialog->getName().istGleich(dialogName))
+                if (dialog->getName().isEqual(dialogName))
                 {
                     exists = 1;
                     break;
@@ -170,18 +170,18 @@ void Game::api(char* data)
                 uiml[uimlLen] = 0;
                 UIMLDialog* dialog
                     = new UIMLDialog(uiml, [this](UIMLDialog* dialog) {
-                          window->zBildschirm()->postAction([this, dialog]() {
+                          window->zScreen()->postAction([this, dialog]() {
                               int index = 0;
                               dialogCs.lock();
                               for (UIMLDialog* d : dialogs)
                               {
                                   if (d == dialog)
                                   {
-                                      window->zBildschirm()->removeMember(d);
+                                      window->zScreen()->removeMember(d);
                                       dialogs.remove(index);
                                       World::INSTANCE->zKamera()
                                           ->setControlEnabled(
-                                              dialogs.getEintragAnzahl() == 0);
+                                              dialogs.getEntryCount() == 0);
                                       updateRecipieVisibility();
                                       break;
                                   }
@@ -195,7 +195,7 @@ void Game::api(char* data)
                 dialogCs.unlock();
                 updateRecipieVisibility();
                 World::INSTANCE->zKamera()->setControlEnabled(0);
-                window->zBildschirm()->addMember(dialog);
+                window->zScreen()->addMember(dialog);
                 delete[] uiml;
             }
             break;
@@ -213,7 +213,7 @@ void Game::api(char* data)
             memcpy(id, data + 3, idLen);
             id[idLen] = 0;
             NetworkAPIProcessor* processor = dynamic_cast<NetworkAPIProcessor*>(
-                guiView->zZeichnungById(id));
+                guiView->zDrawableById(id));
             int processorId = *(int*)(data + 3 + idLen);
             if (processor
                 && (processorId == -1 || processorId == processor->getId()))
@@ -242,7 +242,7 @@ void Game::api(char* data)
             dialogCs.lock();
             for (UIMLDialog* dialog : dialogs)
             {
-                if (dialog->getName().istGleich(dialogName))
+                if (dialog->getName().isEqual(dialogName))
                 {
                     int uimlLen = *(int*)(data + 3 + dialogNameLen);
                     char* uiml = new char[uimlLen + 1];
@@ -261,9 +261,9 @@ void Game::api(char* data)
 void Game::closeCurrentDialog()
 {
     dialogCs.lock();
-    if (dialogs.getEintragAnzahl() > 0)
+    if (dialogs.getEntryCount() > 0)
     {
-        UIMLDialog* d = dialogs.get(dialogs.getEintragAnzahl() - 1);
+        UIMLDialog* d = dialogs.get(dialogs.getEntryCount() - 1);
         d->close();
     }
     dialogCs.unlock();
@@ -278,19 +278,19 @@ void Game::setTargetUIML(Framework::Text uiml)
 {
     if (uiml.getLength())
     {
-        window->zBildschirm()->lock();
+        window->zScreen()->lock();
         targetUIMLView->setUIML(uiml);
         targetUIMLView->layout();
-        window->zBildschirm()->unlock();
+        window->zScreen()->unlock();
         targetUIMLView->setSize(targetUIMLView->calculateContentSize());
         targetUIMLView->setPosition(
-            window->zBildschirm()->zGraphicsApi()->getBackBufferSize()
+            window->zScreen()->zGraphicsApi()->getBackBufferSize()
             - targetUIMLView->getSize());
-        targetUIMLView->addStyle(UIMLView::Style::Sichtbar);
+        targetUIMLView->addStyle(UIMLView::Style::Visible);
     }
     else
     {
-        targetUIMLView->removeStyle(UIMLView::Style::Sichtbar);
+        targetUIMLView->removeStyle(UIMLView::Style::Visible);
     }
 }
 
@@ -298,24 +298,24 @@ void Game::updateRecipieVisibility()
 {
     if (!recipieVisible)
     {
-        if (dialogs.getEintragAnzahl() > 0)
+        if (dialogs.getEntryCount() > 0)
         {
             recipieVisible = 1;
-            window->zBildschirm()->addMember(
-                dynamic_cast<Zeichnung*>(filter->getThis()));
-            window->zBildschirm()->addMember(
-                dynamic_cast<Zeichnung*>(searchIcon->getThis()));
+            window->zScreen()->addMember(
+                dynamic_cast<Drawable*>(filter->getThis()));
+            window->zScreen()->addMember(
+                dynamic_cast<Drawable*>(searchIcon->getThis()));
         }
     }
     else
     {
-        if (dialogs.getEintragAnzahl() == 0)
+        if (dialogs.getEntryCount() == 0)
         {
             recipieVisible = 0;
-            window->zBildschirm()->removeMember(filter);
-            window->zBildschirm()->removeMember(searchIcon);
+            window->zScreen()->removeMember(filter);
+            window->zScreen()->removeMember(searchIcon);
             if (itemListContainer)
-                itemListContainer->removeStyle(Fenster::Style::Sichtbar);
+                itemListContainer->removeStyle(Window::Style::Visible);
         }
     }
 }
@@ -325,16 +325,16 @@ void Game::showItemList()
     if (!itemListContainer)
     {
         itemListContainer = new ItemListContainer();
-        window->zBildschirm()->addMember(
-            dynamic_cast<Zeichnung*>(itemListContainer->getThis()));
+        window->zScreen()->addMember(
+            dynamic_cast<Drawable*>(itemListContainer->getThis()));
     }
-    itemListContainer->addStyle(Fenster::Style::Sichtbar);
+    itemListContainer->addStyle(Window::Style::Visible);
 }
 
 bool Game::isItemListVisible()
 {
     return itemListContainer
-        && itemListContainer->hatStyle(Fenster::Style::Sichtbar);
+        && itemListContainer->hasStyle(Window::Style::Visible);
 }
 
 const Text* Game::zFilterText()
@@ -344,7 +344,7 @@ const Text* Game::zFilterText()
 
 void Game::makeChatButtonVisible()
 {
-    chatButton->addStyle(Knopf::Style::Sichtbar);
+    chatButton->addStyle(Button::Style::Visible);
 }
 
 Chat* Game::zChat() const
@@ -360,10 +360,10 @@ MapWindow* Game::zMap() const
 void Game::hide()
 {
     Menu::hide();
-    window->zBildschirm()->postAction([this]() {
+    window->zScreen()->postAction([this]() {
         if (itemListContainer)
         {
-            window->zBildschirm()->removeMember(itemListContainer);
+            window->zScreen()->removeMember(itemListContainer);
             itemListContainer->release();
             itemListContainer = 0;
         }
@@ -371,14 +371,14 @@ void Game::hide()
 }
 
 ScreenCenter::ScreenCenter()
-    : Zeichnung()
+    : Drawable()
 {
     setPosition(0, 0);
     setSize(uiFactory.initParam.bildschirm->getBackBufferSize());
 }
 
-void ScreenCenter::render(Bild& zRObj)
+void ScreenCenter::render(Image& zRObj)
 {
-    zRObj.drawLinieH(gr.x / 2 - 5, gr.y / 2, 10, 0xFFFFFFFF);
-    zRObj.drawLinieV(gr.x / 2, gr.y / 2 - 5, 10, 0xFFFFFFFF);
+    zRObj.drawLineH(gr.x / 2 - 5, gr.y / 2, 10, 0xFFFFFFFF);
+    zRObj.drawLineV(gr.x / 2, gr.y / 2 - 5, 10, 0xFFFFFFFF);
 }

FactoryCraft/Game.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <Bild.h>
-#include <Knopf.h>
+#include <Image.h>
+#include <Button.h>
 
 #include "Chat.h"
 #include "Dialog.h"
@@ -16,16 +16,16 @@ class InventoryDragSource;
 class Game : public Menu
 {
 private:
-    Framework::Knopf* logout;
-    Framework::TextFeld* debug;
+    Framework::Button* logout;
+    Framework::TextField* debug;
     Framework::Array<UIMLDialog*> dialogs;
     Framework::UIMLView* guiView;
     Framework::UIMLView* targetUIMLView;
     DragController<InventoryDragSource, int>* inventoryDragController;
-    Framework::TextFeld* filter;
-    Framework::BildZ* searchIcon;
+    Framework::TextField* filter;
+    Framework::ImageView* searchIcon;
     ItemListContainer* itemListContainer;
-    Framework::Knopf* chatButton;
+    Framework::Button* chatButton;
     MapWindow* mapWindow;
     Chat* chat;
     bool recipieVisible;
@@ -33,7 +33,7 @@ private:
 
 public:
     // Konstruktor
-    Game(Bildschirm* zScreen);
+    Game(Screen* zScreen);
     ~Game();
 
     void updatePosition(Vec3<float> position, bool target, Vec3<int> targetPos);
@@ -52,9 +52,9 @@ public:
     void hide() override;
 };
 
-class ScreenCenter : public Framework::Zeichnung
+class ScreenCenter : public Framework::Drawable
 {
 public:
     ScreenCenter();
-    virtual void render(Bild& zRObj) override;
+    virtual void render(Image& zRObj) override;
 };

FactoryCraft/Globals.cpp

@@ -13,7 +13,7 @@ void initVariables()
     dlls = new DLLRegister();
     menuRegister = new HashMap<Framework::Text, Framework::RCPointer<Menu>>(
         10, [](Text txt) { return txt.hashCode(); });
-    fontRegister = new HashMap<Framework::Text, Framework::RCPointer<Schrift>>(
+    fontRegister = new HashMap<Framework::Text, Framework::RCPointer<Font>>(
         10, [](Text txt) { return txt.hashCode(); });
     window = 0;
     blockTypes = 0;

FactoryCraft/Globals.h

@@ -1,12 +1,12 @@
 #pragma once
 #include <Array.h>
-#include <Bildschirm.h>
 #include <DLLRegister.h>
-#include <Fenster.h>
+#include <Font.h>
 #include <HashMap.h>
 #include <RCPointer.h>
-#include <Schrift.h>
+#include <Screen.h>
 #include <UIInitialization.h>
+#include <Window.h>
 
 #include "ItemType.h"
 #include "Menu.h"
@@ -19,10 +19,10 @@
 variable Framework::HashMap<Framework::Text, Framework::RCPointer<Menu>>*
     menuRegister;
 variable UIInit uiFactory;
-variable Framework::HashMap<Framework::Text, Framework::RCPointer<Schrift>>*
+variable Framework::HashMap<Framework::Text, Framework::RCPointer<Font>>*
     fontRegister;
 variable DLLRegister* dlls;
-variable Framework::WFenster* window;
+variable Framework::NativeWindow* window;
 variable BlockType** blockTypes;
 variable int blockTypeCount;
 variable ItemType** itemTypes;

FactoryCraft/Initialisierung.cpp

@@ -1,251 +0,0 @@
-#include "Initialisierung.h"
-
-#include <Bildschirm.h>
-#include <DateiSystem.h>
-#include <Fenster.h>
-#include <Fortschritt.h>
-#include <Liste.h>
-#include <MausEreignis.h>
-#include <ToolTip.h>
-
-#include "Globals.h"
-
-Knopf* createKnopf(const Framework::UIInitParam& params)
-{
-    Knopf* ret = Framework::defaultUI(params.schrift, params.bildschirm)
-                     .createKnopf(params);
-    ret->setHintergrundFarbe(0xFF000000);
-    ret->setRahmenFarbe(0xFF2E6DA4);
-    ret->setSchriftFarbe(0xFFFFFFFF);
-    ret->setRahmenBreite(1);
-    ret->setAlphaFeldStrength(10);
-    ret->setAlphaFeldFarbe(0xFF337AB7);
-    return ret;
-}
-
-TextFeld* createTextFeld(const Framework::UIInitParam& params)
-{
-    TextFeld* ret = Framework::defaultUI(params.schrift, params.bildschirm)
-                        .createTextFeld(params);
-    ret->setRahmenFarbe(0xFF6d6d6d);
-    ret->setHintergrundFarbe(0xFF000000);
-    ret->setAlphaFeldFarbe(0xFF3d3d3d);
-    ret->setAlphaFeldStrength(10);
-    return ret;
-}
-
-KontrollKnopf* createKontrollKnopf(const Framework::UIInitParam& params)
-{
-    KontrollKnopf* ret = Framework::defaultUI(params.schrift, params.bildschirm)
-                             .createKontrollKnopf(params);
-    ret->removeStyle(KontrollKnopf::Style::Rahmen);
-    ret->setRahmenFarbe(0xFF2E6DA4);
-    ret->setHintergrundFarbe(0xFF000000);
-    ret->setKAFFarbe(0xFF3d3d3d);
-    ret->setKAFStrength(10);
-    ret->loadData("data/images/system.ltdb");
-    return ret;
-}
-
-ObjTabelle* createObjTabelle(const Framework::UIInitParam& params)
-{
-    ObjTabelle* ret = Framework::defaultUI(params.schrift, params.bildschirm)
-                          .createObjTabelle(params);
-    ret->setRahmenFarbe(0xFF6d6d6d);
-    ret->setHintergrundFarbe(0xFF000000);
-    ret->setRasterFarbe(0xFF6d6d6d);
-    ret->setVertikalScrollPos(0);
-    ret->setHorizontalScrollPos(0);
-    return ret;
-}
-
-Fenster* createFenster(const Framework::UIInitParam& params)
-{
-    Fenster* ret = Framework::defaultUI(params.schrift, params.bildschirm)
-                       .createFenster(params);
-    ret->setTitel("");
-    ret->zTTextFeld()->setRahmenFarbe(0xFF52525E);
-    ret->setRFarbe(0xFF52525E);
-    return ret;
-}
-
-Knopf* initKnopf(int x, int y, int br, int hö, __int64 style, const char* titel)
-{
-    Knopf* ret = uiFactory.createKnopf(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    ret->setText(titel);
-    return ret;
-}
-
-KontrollKnopf* initKontrollKnopf(
-    int x, int y, int br, int hö, __int64 style, const char* txt)
-{
-    KontrollKnopf* ret = uiFactory.createKontrollKnopf(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setText(txt);
-    ret->setSText(txt);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    return ret;
-}
-
-Fenster* initFenster(
-    int x, int y, int br, int hö, __int64 style, const char* titel)
-{
-    Fenster* ret = uiFactory.createFenster(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    if (ret->hatStyle(Fenster::Style::Titel))
-    {
-        ret->setTitel(titel);
-    }
-    return ret;
-}
-
-TextFeld* initTextFeld(
-    int x, int y, int br, int hö, __int64 style, const char* txt)
-{
-    TextFeld* ret = uiFactory.createTextFeld(uiFactory.initParam);
-    ret->setStyle(style);
-    ret->setText(txt);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    return ret;
-}
-
-BildZ* initBildZ(int x, int y, int br, int hö, __int64 style, Bild* b)
-{
-    BildZ* ret = uiFactory.createBildZ(uiFactory.initParam);
-    ret->setStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    if (b) ret->setBildZ(b);
-    return ret;
-}
-
-AuswahlBox* initAuswahlBox(int x,
-    int y,
-    int br,
-    int hö,
-    __int64 style,
-    std::initializer_list<const char*> values)
-{
-    AuswahlBox* ret = uiFactory.createAuswahlBox(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    for (auto i = values.begin(); i != values.end(); i++)
-        ret->addEintrag(*i);
-    return ret;
-}
-
-ObjTabelle* initObjTabelle(int x,
-    int y,
-    int br,
-    int hö,
-    __int64 style,
-    std::initializer_list<OBJTabelleSpalteIni> spalten,
-    int überschriftHöhe)
-{
-    ObjTabelle* ret = uiFactory.createObjTabelle(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    for (auto i = spalten.begin(); i != spalten.end(); i++)
-    {
-        ret->addSpalte(i->name);
-        ret->setSpaltenBreite(i->name, i->breite);
-        if ((style | ObjTabelle::Style::SpaltenBreiteMin) == style)
-            ret->setMinSpaltenBreite(i->name, i->minBreite);
-        if ((style | ObjTabelle::Style::SpaltenBreiteMax) == style)
-            ret->setMaxSpaltenBreite(i->name, i->maxBreite);
-        if (überschriftHöhe)
-        {
-            if (ret->getZeilenNummer("Überschrift") < 0)
-            {
-                ret->addZeile(0, "Überschrift");
-                ret->setZeilenHeight(0, 20);
-            }
-            ret->setZeichnungZ(i->name,
-                "Überschrift",
-                initTextFeld(0,
-                    0,
-                    i->breite,
-                    20,
-                    TextFeld::Style::Text | TextFeld::Style::Center,
-                    i->name));
-        }
-    }
-    return ret;
-}
-
-LDiag* initLinienDiagramm(
-    int x, int y, int br, int hö, __int64 style, DiagDaten* data)
-{
-    LDiag* ret = uiFactory.createLDiag(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    if (data) ret->setDiagDatenZ(data);
-    return ret;
-}
-
-AuswahlListe* initAuswahlListe(int x,
-    int y,
-    int br,
-    int hö,
-    __int64 style,
-    std::initializer_list<const char*> values)
-{
-    AuswahlListe* ret = uiFactory.createAuswahlListe(uiFactory.initParam);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    ret->addStyle(style);
-    for (auto i = values.begin(); i != values.end(); i++)
-        ret->addEintrag(*i);
-    ret->update();
-    return ret;
-}
-
-ZeichnungHintergrund* initZeichnungHintergrund(
-    int x, int y, int br, int hö, __int64 style, int farbe)
-{
-    ZeichnungHintergrund* ret = new ZeichnungHintergrund();
-    ret->setStyle(style);
-    ret->setHintergrundFarbe(farbe);
-    if (ret->hatStyle(ZeichnungHintergrund::Style::Rahmen))
-    {
-        ret->setRahmenBreite(1);
-        ret->setRahmenFarbe(0xFF00FF00);
-    }
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    return ret;
-}
-
-void initToolTip(Zeichnung* obj, const char* txt)
-{
-    obj->setToolTipText(
-        txt, uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
-    obj->zToolTip()->addStyle(TextFeld::Style::Mehrzeilig);
-}
-
-FBalken* initFBalken(int x, int y, int br, int hö, __int64 style)
-{
-    FBalken* ret = uiFactory.createFBalken(uiFactory.initParam);
-    ret->addStyle(style);
-    ret->setPosition(x, y);
-    ret->setSize(br, hö);
-    LTDBDatei* datei = new LTDBDatei();
-    datei->setDatei(new Text("data/images/system.ltdb"));
-    datei->leseDaten(0);
-    Bild* fbhb = datei->laden(0, new Text("fortschrittleh"));
-    ret->setHintergrundBildZ(fbhb);
-    Bild* fbfhb = datei->laden(0, new Text("fortschrittvol"));
-    datei->release();
-    ret->setFBgBildZ(fbfhb);
-    return ret;
-}

FactoryCraft/Initialisierung.h

@@ -1,53 +0,0 @@
-#ifndef Initialisierung_H
-#define Initialisierung_H
-
-#include <AuswahlBox.h>
-#include <Bild.h>
-#include <Diagramm.h>
-#include <Fortschritt.h>
-#include <initializer_list>
-#include <Knopf.h>
-#include <Tabelle.h>
-#include <UIInitialization.h>
-
-using namespace Framework;
-
-struct OBJTabelleSpalteIni
-{
-    const char* name;
-    int breite;
-    int minBreite;
-    int maxBreite;
-};
-
-Knopf* createKnopf(const Framework::UIInitParam& params);
-TextFeld* createTextFeld(const Framework::UIInitParam& params);
-KontrollKnopf* createKontrollKnopf(const Framework::UIInitParam& params);
-ObjTabelle* createObjTabelle(const Framework::UIInitParam& params);
-Fenster* createFenster(const Framework::UIInitParam& params);
-
-Knopf* initKnopf(
-    int x, int y, int br, int hö, __int64 style, const char* titel);
-KontrollKnopf* initKontrollKnopf(
-    int x, int y, int br, int hö, __int64 style, const char* txt);
-TextFeld* initTextFeld(
-    int x, int y, int br, int hö, __int64 style, const char* txt);
-BildZ* initBildZ(int x, int y, int br, int hö, __int64 style, Bild* b);
-AuswahlBox* initAuswahlBox(int x,
-    int y,
-    int br,
-    int hö,
-    __int64 style,
-    std::initializer_list<const char*> values);
-ObjTabelle* initObjTabelle(int x,
-    int y,
-    int br,
-    int hö,
-    __int64 style,
-    std::initializer_list<OBJTabelleSpalteIni> spalten,
-    int überschriftHöhe);
-LDiag* initLinienDiagramm(
-    int x, int y, int br, int hö, __int64 style, DiagDaten* data);
-FBalken* initFBalken(int x, int y, int br, int hö, __int64 style);
-
-#endif

FactoryCraft/Initialization.cpp

@@ -0,0 +1,253 @@
+#include "Initialization.h"
+
+#include <FileSystem.h>
+#include <List.h>
+#include <MouseEvent.h>
+#include <Progress.h>
+#include <Screen.h>
+#include <ToolTip.h>
+#include <Window.h>
+
+#include "Globals.h"
+
+Button* createButton(const Framework::UIInitParam& params)
+{
+    Button* ret = Framework::defaultUI(params.font, params.bildschirm)
+                      .createButton(params);
+    ret->setBackgroundColor(0xFF000000);
+    ret->setBorderColor(0xFF2E6DA4);
+    ret->setFontColor(0xFFFFFFFF);
+    ret->setBorderWidth(1);
+    ret->setAlphaFieldStrength(10);
+    ret->setAlphaFieldColor(0xFF337AB7);
+    return ret;
+}
+
+TextField* createTextField(const Framework::UIInitParam& params)
+{
+    TextField* ret = Framework::defaultUI(params.font, params.bildschirm)
+                         .createTextField(params);
+    ret->setBorderColor(0xFF6d6d6d);
+    ret->setBackgroundColor(0xFF000000);
+    ret->setAlphaFieldColor(0xFF3d3d3d);
+    ret->setAlphaFieldStrength(10);
+    return ret;
+}
+
+CheckBox* createCheckBox(const Framework::UIInitParam& params)
+{
+    CheckBox* ret = Framework::defaultUI(params.font, params.bildschirm)
+                        .createCheckBox(params);
+    ret->removeStyle(CheckBox::Style::Border);
+    ret->setBorderColor(0xFF2E6DA4);
+    ret->setBackgroundColor(0xFF000000);
+    ret->setClickAFColor(0xFF3d3d3d);
+    ret->setClickAFStrength(10);
+    ret->loadData("data/images/system.ltdb");
+    return ret;
+}
+
+ObjTable* createObjTable(const Framework::UIInitParam& params)
+{
+    ObjTable* ret = Framework::defaultUI(params.font, params.bildschirm)
+                        .createObjTable(params);
+    ret->setBorderColor(0xFF6d6d6d);
+    ret->setBackgroundColor(0xFF000000);
+    ret->setGridColor(0xFF6d6d6d);
+    ret->setVerticalScrollPos(0);
+    ret->setHorizontalScrollPos(0);
+    return ret;
+}
+
+Window* createWindow(const Framework::UIInitParam& params)
+{
+    Window* ret = Framework::defaultUI(params.font, params.bildschirm)
+                      .createWindow(params);
+    ret->setTitel("");
+    ret->zTTextField()->setBorderColor(0xFF52525E);
+    ret->setBorderColor(0xFF52525E);
+    return ret;
+}
+
+Button* initButton(
+    int x, int y, int br, int height, __int64 style, const char* titel)
+{
+    Button* ret = uiFactory.createButton(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    ret->setText(titel);
+    return ret;
+}
+
+CheckBox* initCheckBox(
+    int x, int y, int br, int height, __int64 style, const char* txt)
+{
+    CheckBox* ret = uiFactory.createCheckBox(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setText(txt);
+    ret->setSText(txt);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    return ret;
+}
+
+Window* initWindow(
+    int x, int y, int br, int height, __int64 style, const char* titel)
+{
+    Window* ret = uiFactory.createWindow(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    if (ret->hasStyle(Window::Style::Title))
+    {
+        ret->setTitel(titel);
+    }
+    return ret;
+}
+
+TextField* initTextField(
+    int x, int y, int br, int height, __int64 style, const char* txt)
+{
+    TextField* ret = uiFactory.createTextField(uiFactory.initParam);
+    ret->setStyle(style);
+    ret->setText(txt);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    return ret;
+}
+
+ImageView* initImageView(
+    int x, int y, int br, int height, __int64 style, Image* b)
+{
+    ImageView* ret = uiFactory.createImageView(uiFactory.initParam);
+    ret->setStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    if (b) ret->setImageZ(b);
+    return ret;
+}
+
+SelectionBox* initSelectionBox(int x,
+    int y,
+    int br,
+    int height,
+    __int64 style,
+    std::initializer_list<const char*> values)
+{
+    SelectionBox* ret = uiFactory.createSelectionBox(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    for (auto i = values.begin(); i != values.end(); i++)
+        ret->addEntry(*i);
+    return ret;
+}
+
+ObjTable* initObjTable(int x,
+    int y,
+    int br,
+    int height,
+    __int64 style,
+    std::initializer_list<OBJTabelleSpalteIni> spalten,
+    int titleHeight)
+{
+    ObjTable* ret = uiFactory.createObjTable(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    for (auto i = spalten.begin(); i != spalten.end(); i++)
+    {
+        ret->addColumn(i->name);
+        ret->setColumnWidth(i->name, i->breite);
+        if ((style | ObjTable::Style::ColumnWidthMin) == style)
+            ret->setMinColumnWidth(i->name, i->minBreite);
+        if ((style | ObjTable::Style::ColumnWidthMax) == style)
+            ret->setMaxColumnWidth(i->name, i->maxBreite);
+        if (titleHeight)
+        {
+            if (ret->getRowNumber("title") < 0)
+            {
+                ret->addRow(0, "title");
+                ret->setRowHeight(0, 20);
+            }
+            ret->setDrawableZ(i->name,
+                "title",
+                initTextField(0,
+                    0,
+                    i->breite,
+                    20,
+                    TextField::Style::Text | TextField::Style::Center,
+                    i->name));
+        }
+    }
+    return ret;
+}
+
+LineDiagram* initLinieDiagram(
+    int x, int y, int br, int height, __int64 style, DiagramData* data)
+{
+    LineDiagram* ret = uiFactory.createLineDiagram(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    if (data) ret->setDiagramDataZ(data);
+    return ret;
+}
+
+SelectionList* initSelectionList(int x,
+    int y,
+    int br,
+    int height,
+    __int64 style,
+    std::initializer_list<const char*> values)
+{
+    SelectionList* ret = uiFactory.createSelectionList(uiFactory.initParam);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    ret->addStyle(style);
+    for (auto i = values.begin(); i != values.end(); i++)
+        ret->addEntry(*i);
+    ret->update();
+    return ret;
+}
+
+DrawableBackground* initDrawingBackground(
+    int x, int y, int br, int height, __int64 style, int farbe)
+{
+    DrawableBackground* ret = new DrawableBackground();
+    ret->setStyle(style);
+    ret->setBackgroundColor(farbe);
+    if (ret->hasStyle(DrawableBackground::Style::Border))
+    {
+        ret->setBorderWidth(1);
+        ret->setBorderColor(0xFF00FF00);
+    }
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    return ret;
+}
+
+void initToolTip(Drawable* obj, const char* txt)
+{
+    obj->setToolTipText(
+        txt, uiFactory.initParam.bildschirm, uiFactory.initParam.font);
+    obj->zToolTip()->addStyle(TextField::Style::Multiline);
+}
+
+ProgressBar* initProgressBar(int x, int y, int br, int height, __int64 style)
+{
+    ProgressBar* ret = uiFactory.createProgressBar(uiFactory.initParam);
+    ret->addStyle(style);
+    ret->setPosition(x, y);
+    ret->setSize(br, height);
+    LTDBFile* file = new LTDBFile();
+    file->setFile(new Text("data/images/system.ltdb"));
+    file->readData(0);
+    Image* fbhb = file->load(0, new Text("fortschrittleh"));
+    ret->setBackgroundImageZ(fbhb);
+    Image* fbfhb = file->load(0, new Text("fortschrittvol"));
+    file->release();
+    ret->setFBgImageZ(fbfhb);
+    return ret;
+}

FactoryCraft/Initialization.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <Button.h>
+#include <Diagram.h>
+#include <Image.h>
+#include <initializer_list>
+#include <Progress.h>
+#include <SelectionBox.h>
+#include <Table.h>
+#include <UIInitialization.h>
+
+using namespace Framework;
+
+struct OBJTabelleSpalteIni
+{
+    const char* name;
+    int breite;
+    int minBreite;
+    int maxBreite;
+};
+
+Button* createButton(const Framework::UIInitParam& params);
+TextField* createTextField(const Framework::UIInitParam& params);
+CheckBox* createCheckBox(const Framework::UIInitParam& params);
+ObjTable* createObjTable(const Framework::UIInitParam& params);
+Window* createWindow(const Framework::UIInitParam& params);
+
+Button* initButton(
+    int x, int y, int br, int height, __int64 style, const char* titel);
+CheckBox* initCheckBox(
+    int x, int y, int br, int height, __int64 style, const char* txt);
+TextField* initTextField(
+    int x, int y, int br, int height, __int64 style, const char* txt);
+ImageView* initImageView(
+    int x, int y, int br, int height, __int64 style, Image* b);
+SelectionBox* initSelectionBox(int x,
+    int y,
+    int br,
+    int height,
+    __int64 style,
+    std::initializer_list<const char*> values);
+ObjTable* initObjTable(int x,
+    int y,
+    int br,
+    int height,
+    __int64 style,
+    std::initializer_list<OBJTabelleSpalteIni> spalten,
+    int titleHeight);
+LineDiagram* initLinieDiagram(
+    int x, int y, int br, int height, __int64 style, DiagramData* data);
+ProgressBar* initProgressBar(int x, int y, int br, int height, __int64 style);

FactoryCraft/InventoryView.cpp

@@ -1,6 +1,6 @@
 #include "InventoryView.h"
 
-#include <Bild.h>
+#include <Image.h>
 #include <XML.h>
 
 #include "DragController.h"
@@ -17,28 +17,28 @@ InventoryElement::InventoryElement()
 //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig ist
 bool InventoryElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("inventory");
+    return element.getName().isEqual("inventory");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* InventoryElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* InventoryElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     Text targetValue = element.getAttributeValue("target");
     Vec3<int> blockPos(0, 0, 0);
     Framework::Either<int, VecN<int, 4>> target((int)targetValue);
-    if (targetValue.hat(','))
+    if (targetValue.has(','))
     {
         Text* first
-            = targetValue.getTeilText(0, targetValue.positionVon(",", 0) + 1);
+            = targetValue.getTeilText(0, targetValue.positionOf(",", 0) + 1);
         Text* second
-            = targetValue.getTeilText(targetValue.positionVon(",", 0) + 1,
-                targetValue.positionVon(",", 1));
+            = targetValue.getTeilText(targetValue.positionOf(",", 0) + 1,
+                targetValue.positionOf(",", 1));
         Text* third
-            = targetValue.getTeilText(targetValue.positionVon(",", 1) + 1,
-                targetValue.positionVon(",", 2));
+            = targetValue.getTeilText(targetValue.positionOf(",", 1) + 1,
+                targetValue.positionOf(",", 2));
         Text* forth
-            = targetValue.getTeilText(targetValue.positionVon(",", 2) + 1);
+            = targetValue.getTeilText(targetValue.positionOf(",", 2) + 1);
         target = Framework::Either<int, VecN<int, 4>>(Framework::VecN<int, 4>(
             {(int)*first, (int)*second, (int)*third, (int)*forth}));
         first->release();
@@ -53,15 +53,15 @@ Framework::Zeichnung* InventoryElement::parseElement(
 }
 
 bool InventoryElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void InventoryElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -70,16 +70,16 @@ void InventoryElement::layout(Framework::XML::Element& element,
 }
 
 void SlotInfo::render(
-    int x, int y, Framework::Bild& rObj, bool selected, bool lightBackground)
+    int x, int y, Framework::Image& rObj, bool selected, bool lightBackground)
 {
     const Text* filter
         = dynamic_cast<Game*>((Menu*)menuRegister->get("game"))->zFilterText();
     TextRenderer tr;
-    tr.setSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    tr.setSchriftSize(12);
+    tr.setFontZ(
+        dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    tr.setFontSize(12);
     bool filterMatch
-        = filter->getLength() > 0 && this->name.hat(filter->getText());
+        = filter->getLength() > 0 && this->name.has(filter->getText());
     rObj.fillRegion(
         x, y, 52, 52, selected || filterMatch ? 0xFFFFFFFF : 0xFF52525E);
     rObj.fillRegion(x + 1,
@@ -91,7 +91,7 @@ void SlotInfo::render(
                                    : (filterMatch ? 0xFF222222 : 0xFF000000));
     if (itemCount > 0)
     {
-        rObj.alphaBild(x + 1, y + 1, 50, 50, *zItem);
+        rObj.alphaImage(x + 1, y + 1, 50, 50, *zItem);
         if (hp < maxHp)
         {
             rObj.fillRegion(x + 1, y + 47, 50, 2, 0xFF000000);
@@ -114,7 +114,7 @@ void SlotInfo::render(
             tmpCount = tmpCount / 1024;
         Text count = tmpCount;
         count += units[i];
-        tr.renderText(x + 45 - tr.getTextBreite(count),
+        tr.renderText(x + 45 - tr.getTextWidth(count),
             y + 45 - tr.getTextHeight(count),
             count,
             rObj,
@@ -124,7 +124,7 @@ void SlotInfo::render(
 
 InventoryView::InventoryView(
     Text id, Either<int, VecN<int, 4>> target, int rowSize, Text slotNameFilter)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       NetworkAPIProcessor(),
       rowSize(rowSize),
       target(target),
@@ -136,8 +136,8 @@ InventoryView::InventoryView(
       currentTooltipSlot(-1),
       requestetTooltipSlot(-1)
 {
-    setStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Erlaubt);
+    setStyle(DrawableBackground::Style::Visible
+             | DrawableBackground::Style::Allowed);
     char* msg = new char[id.getLength() + slotNameFilter.getLength() + 7];
     msg[0] = 0;
     msg[1] = (char)id.getLength();
@@ -150,7 +150,7 @@ InventoryView::InventoryView(
     World::INSTANCE->zClient()->inventoryAPIRequest(
         target, msg, id.getLength() + slotNameFilter.getLength() + 7);
     delete[] msg;
-    setNeedToolTipEvent([this](Zeichnung* z, Punkt p) {
+    setNeedToolTipEvent([this](Drawable* z, Point p) {
         int slot = getSlotByLocalPos(p);
         if (currentTooltipSlot != slot && currentTooltipSlot != -1)
         {
@@ -196,7 +196,7 @@ InventoryView::~InventoryView()
     delete[] msg;
 }
 
-int InventoryView::getSlotByLocalPos(Punkt pos)
+int InventoryView::getSlotByLocalPos(Point pos)
 {
     int x = 0;
     int y = 0;
@@ -253,7 +253,7 @@ void InventoryView::api(char* message)
                 }
                 slots->add(info);
             }
-            window->zBildschirm()->postAction([this, slots]() {
+            window->zScreen()->postAction([this, slots]() {
                 if (this->slots) this->slots->release();
                 this->slots = slots;
             });
@@ -264,7 +264,7 @@ void InventoryView::api(char* message)
             if (!slots) return;
             int id = *(int*)(message + 1);
             int count = *(int*)(message + 5);
-            for (int i = 0; i < slots->getEintragAnzahl(); i++)
+            for (int i = 0; i < slots->getEntryCount(); i++)
             {
                 if (slots->get(i).id == id)
                 {
@@ -293,7 +293,7 @@ void InventoryView::api(char* message)
         {
             if (!slots) return;
             int id = *(int*)(message + 1);
-            for (int i = 0; i < slots->getEintragAnzahl(); i++)
+            for (int i = 0; i < slots->getEntryCount(); i++)
             {
                 if (slots->get(i).id == id)
                 {
@@ -346,12 +346,12 @@ void InventoryView::api(char* message)
 
 bool InventoryView::tick(double tickVal)
 {
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void InventoryView::render(Bild& rObj)
+void InventoryView::render(Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     if (slots)
     {
@@ -374,14 +374,14 @@ void InventoryView::render(Bild& rObj)
     rObj.releaseDrawOptions();
 }
 
-void InventoryView::doMausEreignis(MausEreignis& me, bool userRet)
+void InventoryView::doMouseEvent(MouseEvent& me, bool userRet)
 {
     mausPos.x = me.originalX;
     mausPos.y = me.originalY;
     if (!slots) return;
-    if (me.id == ME_Bewegung)
+    if (me.id == ME_Move)
     {
-        if (getSlotByLocalPos(Punkt(me.mx, me.my)) != currentTooltipSlot)
+        if (getSlotByLocalPos(Point(me.mx, me.my)) != currentTooltipSlot)
         {
             if (currentTooltipSlot != -1)
             {
@@ -404,7 +404,7 @@ void InventoryView::doMausEreignis(MausEreignis& me, bool userRet)
     {
         if (me.mx >= x && me.mx < x + 50 && me.my >= y && me.my < y + 50)
         {
-            if (me.id == ME_RLinks)
+            if (me.id == ME_RLeft)
             {
                 if (!controller->getCurrentDragContainer()
                     && info.itemCount > 0)
@@ -480,7 +480,7 @@ void InventoryView::doMausEreignis(MausEreignis& me, bool userRet)
         }
         slot++;
     }
-    ZeichnungHintergrund::doMausEreignis(me, userRet);
+    DrawableBackground::doMouseEvent(me, userRet);
 }
 
 Framework::Either<int, Framework::VecN<int, 4>>

FactoryCraft/InventoryView.h

@@ -13,15 +13,15 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
@@ -36,11 +36,11 @@ struct SlotInfo
     float durability;
     float maxDurability;
     Framework::Text name;
-    Framework::Bild* zItem;
+    Framework::Image* zItem;
 
     void render(int x,
         int y,
-        Framework::Bild& rObj,
+        Framework::Image& rObj,
         bool selected,
         bool lightBackground);
 };
@@ -52,7 +52,7 @@ public:
     getInventoryTarget() const = 0;
 };
 
-class InventoryView : public Framework::ZeichnungHintergrund,
+class InventoryView : public Framework::DrawableBackground,
                       public NetworkAPIProcessor,
                       public InventoryDragSource
 {
@@ -63,12 +63,12 @@ private:
     Framework::Text slotNameFilter;
     Framework::Text id;
     Framework::Array<SlotInfo>* slots;
-    Framework::Punkt mausPos;
+    Framework::Point mausPos;
     int dragStartId;
     int dragStopId;
     int currentTooltipSlot;
     int requestetTooltipSlot;
-    int getSlotByLocalPos(Framework::Punkt pos);
+    int getSlotByLocalPos(Framework::Point pos);
 
 public:
     InventoryView(Framework::Text id,
@@ -78,8 +78,8 @@ public:
     ~InventoryView();
     void api(char* message) override;
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
     Framework::Either<int, Framework::VecN<int, 4>>
     getInventoryTarget() const override;
 };

FactoryCraft/ItemBar.cpp

@@ -1,7 +1,7 @@
 #include "ItemBar.h"
 
-#include <Bild.h>
-#include <DateiSystem.h>
+#include <Image.h>
+#include <FileSystem.h>
 #include <XML.h>
 
 #include "Globals.h"
@@ -15,11 +15,11 @@ ItemBarElement::ItemBarElement()
 //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig ist
 bool ItemBarElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("itemBar");
+    return element.getName().isEqual("itemBar");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* ItemBarElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* ItemBarElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     return new ItemBarView(element.getAttributeValue("id"),
@@ -29,15 +29,15 @@ Framework::Zeichnung* ItemBarElement::parseElement(
 }
 
 bool ItemBarElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void ItemBarElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -51,7 +51,7 @@ ItemBarView::ItemBarView(Framework::Text id,
     int rowSize,
     int targetEntity,
     Framework::Text slotNameFilter)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       NetworkAPIProcessor(),
       id(id),
       rowSize(rowSize),
@@ -119,7 +119,7 @@ void ItemBarView::api(char* message)
                 }
                 slots->add(info);
             }
-            window->zBildschirm()->postAction([this, slots]() {
+            window->zScreen()->postAction([this, slots]() {
                 if (this->slots) this->slots->release();
                 this->slots = slots;
             });
@@ -129,7 +129,7 @@ void ItemBarView::api(char* message)
         {
             int id = *(int*)(message + 1);
             int count = *(int*)(message + 5);
-            for (int i = 0; i < slots->getEintragAnzahl(); i++)
+            for (int i = 0; i < slots->getEntryCount(); i++)
             {
                 if (slots->get(i).id == id)
                 {
@@ -144,7 +144,7 @@ void ItemBarView::api(char* message)
     case 2: // add new stack
         {
             int id = *(int*)(message + 1);
-            for (int i = 0; i < slots->getEintragAnzahl(); i++)
+            for (int i = 0; i < slots->getEntryCount(); i++)
             {
                 if (slots->get(i).id == id)
                 {
@@ -175,9 +175,9 @@ void ItemBarView::api(char* message)
     }
 }
 
-void ItemBarView::render(Bild& rObj)
+void ItemBarView::render(Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     if (slots)
     {

FactoryCraft/ItemBar.h

@@ -13,21 +13,21 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class ItemBarView : public Framework::ZeichnungHintergrund,
+class ItemBarView : public Framework::DrawableBackground,
                     public NetworkAPIProcessor
 {
 private:
@@ -45,5 +45,5 @@ public:
         Framework::Text slotNameFilter);
     ~ItemBarView();
     void api(char* message) override;
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };

FactoryCraft/ItemList.cpp

@@ -1,8 +1,8 @@
 #include "ItemList.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 #include <Scroll.h>
-#include <TextFeld.h>
+#include <TextField.h>
 
 #include "Game.h"
 #include "Globals.h"
@@ -10,15 +10,15 @@
 #include "World.h"
 
 ItemList::ItemList()
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       currentTooltipSlot(-1)
 {
-    setStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Erlaubt);
+    setStyle(DrawableBackground::Style::Visible
+             | DrawableBackground::Style::Allowed);
     slotList = new int[itemTypeCount];
     memset(slotList, 0, sizeof(int) * itemTypeCount);
     slotCount = 0;
-    setNeedToolTipEvent([this](Zeichnung* z, Punkt p) {
+    setNeedToolTipEvent([this](Drawable* z, Point p) {
         int slot = getSlotByLocalPos(p);
         if (currentTooltipSlot != slot && currentTooltipSlot != -1)
         {
@@ -46,7 +46,7 @@ ItemList::~ItemList()
     delete[] slotList;
 }
 
-int ItemList::getSlotByLocalPos(Framework::Punkt pos)
+int ItemList::getSlotByLocalPos(Framework::Point pos)
 {
     int x = 0;
     int y = 0;
@@ -55,7 +55,7 @@ int ItemList::getSlotByLocalPos(Framework::Punkt pos)
         if (pos.x >= x && pos.x < x + 50 && pos.y >= y && pos.y < y + 50)
             return slotList[i];
         x += 60;
-        if (x >= getBreite())
+        if (x >= getWidth())
         {
             y += 60;
             x = 0;
@@ -64,13 +64,13 @@ int ItemList::getSlotByLocalPos(Framework::Punkt pos)
     return -1;
 }
 
-void ItemList::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void ItemList::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
     mausPos.x = me.originalX;
     mausPos.y = me.originalY;
-    if (me.id == ME_Bewegung)
+    if (me.id == ME_Move)
     {
-        if (getSlotByLocalPos(Punkt(me.mx, me.my)) != currentTooltipSlot)
+        if (getSlotByLocalPos(Point(me.mx, me.my)) != currentTooltipSlot)
         {
             if (currentTooltipSlot != -1)
             {
@@ -82,21 +82,21 @@ void ItemList::doMausEreignis(Framework::MausEreignis& me, bool userRet)
             currentTooltipSlot = -1;
         }
     }
-    else if (me.id == ME_RLinks)
+    else if (me.id == ME_RLeft)
     {
-        int pos = getSlotByLocalPos(Punkt(me.mx, me.my));
+        int pos = getSlotByLocalPos(Point(me.mx, me.my));
         if (pos >= 0)
         {
             World::INSTANCE->zClient()->craftingUIMLRequest(
                 itemTypes[pos]->getId());
         }
     }
-    ZeichnungHintergrund::doMausEreignis(me, userRet);
+    DrawableBackground::doMouseEvent(me, userRet);
 }
 
 bool ItemList::tick(double time)
 {
-    return ZeichnungHintergrund::tick(time);
+    return DrawableBackground::tick(time);
 }
 
 void ItemList::adjustSize(int parentWidth, int parentHeight)
@@ -110,11 +110,11 @@ void ItemList::adjustSize(int parentWidth, int parentHeight)
         (itemTypeCount / ipr + (itemTypeCount % ipr == 0 ? 0 : 1)) * 60 - 10);
 }
 
-void ItemList::render(Framework::Bild& rObj)
+void ItemList::render(Framework::Image& rObj)
 {
     const Text* filter
         = dynamic_cast<Game*>((Menu*)menuRegister->get("game"))->zFilterText();
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     int x = 0;
     int y = 0;
@@ -122,15 +122,15 @@ void ItemList::render(Framework::Bild& rObj)
     for (int i = 0; i < itemTypeCount; i++)
     {
         if (filter->getLength() > 0
-            && !itemTypes[i]->getName().hat(filter->getText()))
+            && !itemTypes[i]->getName().has(filter->getText()))
         {
             continue;
         }
         slotList[index] = i;
         rObj.fillRegion(x, y, 50, 50, 0xFF222222);
-        rObj.alphaBild(x, y, 50, 50, *itemTypes[i]->zIcon());
+        rObj.alphaImage(x, y, 50, 50, *itemTypes[i]->zIcon());
         x += 60;
-        if (x >= getBreite())
+        if (x >= getWidth())
         {
             x = 0;
             y += 60;
@@ -142,50 +142,47 @@ void ItemList::render(Framework::Bild& rObj)
 }
 
 ItemListContainer::ItemListContainer()
-    : Fenster()
+    : Window()
 {
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    setStyle(
-        Fenster::Style::Erlaubt | Fenster::Style::Rahmen
-        | Fenster::Style::BodyHAlpha | Fenster::Style::Beweglich
-        | Fenster::Style::Titel | Fenster::Style::TitelHAlpha
-        | Fenster::Style::TitelHintergrund | Fenster::Style::BodyHintergrund
-        | Fenster::Style::MEIgnoreInside | Fenster::Style::VScroll
-        | Fenster::Style::BreiteChangeable | Fenster::Style::BodyMinBr
-        | Fenster::Style::BodyMinHi | Fenster::Style::HeightChangeable
-        | Fenster::Style::Closable | Fenster::Style::ClosingHAlpha
-        | Fenster::Style::ClosingKlickBuffer | Fenster::Style::ClosingHAlpha
-        | Fenster::Style::ClosingHintergrund | Style::ClosingHBild
-        | Style::ClosingBuffer);
-    setKBgFarbe(0xA0000000);
-    setTBgFarbe(0xA0000000);
-    setSBgFarbe(0xA0000000);
-    setSize(329, window->zBildschirm()->getBackBufferSize().y - 20);
-    setPosition(
-        window->zBildschirm()->getBackBufferSize().x - getBreite() - 10, 10);
-    setRBreite(2);
-    setRFarbe(0xFF52525E);
+    setStyle(Window::Style::Allowed | Window::Style::Border
+             | Window::Style::BodyBAlpha | Window::Style::Movable
+             | Window::Style::Title | Window::Style::TitleBAlpha
+             | Window::Style::TitleBackground | Window::Style::BodyBackground
+             | Window::Style::MEIgnoreInside | Window::Style::VScroll
+             | Window::Style::WidthChangeable | Window::Style::BodyMinWidth
+             | Window::Style::BodyMinHeight | Window::Style::HeightChangeable
+             | Window::Style::Closable | Window::Style::ClosingBAlpha
+             | Window::Style::ClosingBuffer | Window::Style::ClosingBAlpha
+             | Window::Style::ClosingBackground | Style::ClosingBImage
+             | Style::ClosingBuffer);
+    setBodyBgColor(0xA0000000);
+    setTBgColor(0xA0000000);
+    setCloseBgColor(0xA0000000);
+    setSize(329, window->zScreen()->getBackBufferSize().y - 20);
+    setPosition(window->zScreen()->getBackBufferSize().x - getWidth() - 10, 10);
+    setBorderWidth(2);
+    setBorderColor(0xFF52525E);
     setTitel("Recipies");
-    setTSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    zTTextFeld()->setSize(0, 20);
-    zTTextFeld()->addStyle(TextFeld::Style::Center);
-    setTastaturEreignis(_ret1TE);
-    setKMin(70, 70);
+    setTFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    zTTextField()->setSize(0, 20);
+    zTTextField()->addStyle(TextField::Style::Center);
+    setKeyboardEvent(_ret1TE);
+    setBodyMin(70, 70);
     setVSBScroll(0);
-    zVScrollBar()->setBgFarbe(0xA0000000, 1);
-    setClosingMe([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks) removeStyle(Style::Sichtbar);
+    zVScrollBar()->setBgColor(0xA0000000, 1);
+    setClosingMe([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft) removeStyle(Style::Visible);
         return 1;
     });
-    setSAfStrength(10);
-    setSAfFarbe(0x5F9C0A0A);
-    setSBgBildZ(iconsDat.laden(0, new Text("close.png")));
-    setSKAfFarbe(0xFF9C0A0A);
-    setSKAfStrength(10);
+    setCloseAfStrength(10);
+    setCloseAfColor(0x5F9C0A0A);
+    setCloseBgImageZ(iconsDat.load(0, new Text("close.png")));
+    setCloseClickAfColor(0xFF9C0A0A);
+    setCloseClickAfStrength(10);
 
     list = new ItemList();
     list->setPosition(10, 10);
@@ -194,8 +191,8 @@ ItemListContainer::ItemListContainer()
 
 bool ItemListContainer::tick(double time)
 {
-    list->adjustSize(getInnenBreite() - 35, getInnenHeight());
+    list->adjustSize(getInnerWidth() - 35, getInnerHeight());
     if (zVScrollBar()->getScrollData()->max != list->getHeight() + 20)
         setVSBMax(list->getHeight() + 20);
-    return Fenster::tick(time);
+    return Window::tick(time);
 }

FactoryCraft/ItemList.h

@@ -1,28 +1,28 @@
 #pragma once
 
-#include <Bild.h>
-#include <Fenster.h>
+#include <Image.h>
+#include <Window.h>
 
-class ItemList : public Framework::ZeichnungHintergrund
+class ItemList : public Framework::DrawableBackground
 {
 private:
-    Framework::Punkt mausPos;
+    Framework::Point mausPos;
     int currentTooltipSlot;
     int* slotList;
     int slotCount;
 
-    int getSlotByLocalPos(Framework::Punkt pos);
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    int getSlotByLocalPos(Framework::Point pos);
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 
 public:
     ItemList();
     ~ItemList();
     bool tick(double time) override;
     void adjustSize(int parentWidth, int parentHeight);
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };
 
-class ItemListContainer : public Framework::Fenster
+class ItemListContainer : public Framework::Window
 {
 private:
     ItemList* list;

FactoryCraft/ItemStack.cpp

@@ -11,20 +11,20 @@ ItemStackElement::ItemStackElement()
 
 bool ItemStackElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("itemStack");
+    return element.getName().isEqual("itemStack");
 }
 
-Framework::Zeichnung* ItemStackElement::parseElement(
+Framework::Drawable* ItemStackElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
-    ItemStackView* result = new ItemStackView(dynamic_cast<Framework::Schrift*>(
-        generalFactory.getFactory().initParam.schrift->getThis()));
+    ItemStackView* result = new ItemStackView(dynamic_cast<Framework::Font*>(
+        generalFactory.getFactory().initParam.font->getThis()));
     updateElement(element, *result, generalFactory);
     return result;
 }
 
 bool ItemStackElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     ItemStackView* view = dynamic_cast<ItemStackView*>(&z);
@@ -34,32 +34,31 @@ bool ItemStackElement::updateElement(Framework::XML::Element& element,
     if (tip.exists())
     {
         view->setToolTip((Framework::RCPointer<Framework::XML::Element>)
-                             tip.getFirstElement());
+                tip.getFirstElement());
     }
     int type = (int)element.getAttributeValue("type");
     const ItemType* itemType = zItemType(type);
     if (itemType)
     {
-        view->setHintergrundBildZ(
-            dynamic_cast<Framework::Bild*>(itemType->zIcon()->getThis()));
+        view->setBackgroundImageZ(
+            dynamic_cast<Framework::Image*>(itemType->zIcon()->getThis()));
     }
     return true;
 }
 
-ItemStackView::ItemStackView(Framework::Schrift* schrift)
-    : Framework::ZeichnungHintergrund(),
+ItemStackView::ItemStackView(Framework::Font* font)
+    : Framework::DrawableBackground(),
       count("")
 {
-    setStyle(ZeichnungHintergrund::Style::Erlaubt
-             | ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Hintergrund
-             | ZeichnungHintergrund::Style::HBild
-             | ZeichnungHintergrund::Style::HAlpha
-             | ZeichnungHintergrund::Style::Rahmen);
-    setRahmenBreite(1);
-    setRahmenFarbe(0xFF52525E);
-    tr.setSchriftZ(schrift);
-    tr.setSchriftSize(12);
+    setStyle(
+        DrawableBackground::Style::Allowed | DrawableBackground::Style::Visible
+        | DrawableBackground::Style::Background
+        | DrawableBackground::Style::BImage | DrawableBackground::Style::BAlpha
+        | DrawableBackground::Style::Border);
+    setBorderWidth(1);
+    setBorderColor(0xFF52525E);
+    tr.setFontZ(font);
+    tr.setFontSize(12);
 }
 
 void ItemStackView::setCount(Framework::Text count)
@@ -74,18 +73,18 @@ void ItemStackView::setToolTip(Framework::XML::Element* zToolTipUIML)
     setToolTipZ(tip);
 }
 
-void ItemStackView::render(Framework::Bild& rObj)
+void ItemStackView::render(Framework::Image& rObj)
 {
-    Framework::ZeichnungHintergrund::render(rObj);
+    Framework::DrawableBackground::render(rObj);
     if (rObj.setDrawOptions(pos, gr))
     {
-        if (rObj.setDrawOptions(getRahmenBreite(),
-                getRahmenBreite(),
-                getInnenBreite(),
-                getInnenHeight()))
+        if (rObj.setDrawOptions(getBorderWidth(),
+                getBorderWidth(),
+                getInnerWidth(),
+                getInnerHeight()))
         {
-            tr.renderText(getInnenBreite() - 5 - tr.getTextBreite(count),
-                getInnenHeight() - 5 - tr.getTextHeight(count),
+            tr.renderText(getInnerWidth() - 5 - tr.getTextWidth(count),
+                getInnerHeight() - 5 - tr.getTextHeight(count),
                 count,
                 rObj,
                 0xFFFFFFFF);

FactoryCraft/ItemStack.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Schrift.h>
+#include <Font.h>
 #include <UIMLView.h>
 
 class ItemStackElement : public Framework::UIMLElement
@@ -10,23 +10,23 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
 };
 
-class ItemStackView : public Framework::ZeichnungHintergrund
+class ItemStackView : public Framework::DrawableBackground
 {
 private:
     Framework::Text count;
     Framework::TextRenderer tr;
 
 public:
-    ItemStackView(Framework::Schrift* schrift);
+    ItemStackView(Framework::Font* font);
     void setCount(Framework::Text count);
     void setToolTip(Framework::XML::Element* zToolTipUIML);
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };

FactoryCraft/ItemType.cpp

@@ -23,13 +23,13 @@ int ItemType::getId() const
     return id;
 }
 
-void ItemType::setBild(Framework::Bild* icon)
+void ItemType::setBild(Framework::Image* icon)
 {
     if (this->icon) this->icon->release();
     this->icon = icon;
 }
 
-Framework::Bild* ItemType::zIcon() const
+Framework::Image* ItemType::zIcon() const
 {
     return icon;
 }
@@ -39,7 +39,7 @@ Framework::Model3DData* ItemType::getItemModel() const
     return model.getModel();
 }
 
-Framework::Model3DTextur* ItemType::getItemTextur() const
+Framework::Model3DTexture* ItemType::getItemTextur() const
 {
     return model.getTexture();
 }

FactoryCraft/ItemType.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Bild.h>
+#include <Image.h>
 
 #include "ModelInfo.h"
 
@@ -9,7 +9,7 @@ class ItemType : public virtual Framework::ReferenceCounter
 protected:
     const int id;
     const ModelInfo model;
-    Framework::Bild* icon;
+    Framework::Image* icon;
     Framework::Text name;
     Framework::Text tooltipUIML;
 
@@ -21,10 +21,10 @@ public:
     ~ItemType();
 
     int getId() const;
-    void setBild(Framework::Bild* icon);
-    Framework::Bild* zIcon() const;
+    void setBild(Framework::Image* icon);
+    Framework::Image* zIcon() const;
     Framework::Model3DData* getItemModel() const;
-    Framework::Model3DTextur* getItemTextur() const;
+    Framework::Model3DTexture* getItemTextur() const;
     const Framework::Text& getName() const;
     const Framework::Text& getTooltipUIML() const;
     float getSize() const;

FactoryCraft/ListView.cpp

@@ -1,10 +1,10 @@
 #include "ListView.h"
 
-#include <Bild.h>
-#include <Fenster.h>
-#include <Liste.h>
-#include <Schrift.h>
-#include <TextFeld.h>
+#include <Font.h>
+#include <Image.h>
+#include <List.h>
+#include <TextField.h>
+#include <Window.h>
 #include <XML.h>
 
 #include "World.h"
@@ -15,32 +15,32 @@ ListViewElement::ListViewElement()
 
 bool ListViewElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("listView");
+    return element.getName().isEqual("listView");
 }
 
-Framework::Zeichnung* ListViewElement::parseElement(
+Framework::Drawable* ListViewElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     ListView* result = new ListView();
-    result->list->setSchriftZ(dynamic_cast<Framework::Schrift*>(
-        generalFactory.getFactory().initParam.schrift->getThis()));
+    result->list->setFontZ(dynamic_cast<Framework::Font*>(
+        generalFactory.getFactory().initParam.font->getThis()));
     updateElement(element, *result, generalFactory);
     return result;
 }
 
 bool ListViewElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     ListView* view = dynamic_cast<ListView*>(&z);
     if (!view) return false;
-    for (int index = 0; index < view->list->getEintragAnzahl(); index++)
+    for (int index = 0; index < view->list->getEntryCount(); index++)
     {
         if (!element.selectChildsByName("listItem")
                 .whereAttributeEquals("id", *view->ids.z(index))
                 .exists())
         {
-            view->list->removeEintrag(index);
+            view->list->removeEntry(index);
             view->ids.remove(index);
             index--;
         }
@@ -50,26 +50,26 @@ bool ListViewElement::updateElement(Framework::XML::Element& element,
         element.selectChildsByName("listItem"))
     {
         int index = view->ids.findIndex([zChild](const Framework::Text* zId) {
-            return zId->istGleich(zChild->getAttributeValue("id"));
+            return zId->isEqual(zChild->getAttributeValue("id"));
         });
         if (index < 0)
         {
             Framework::Text id = zChild->getAttributeValue("id");
             view->ids.add(new Framework::Text(id));
-            view->list->addEintrag(zChild->getText());
+            view->list->addEntry(zChild->getText());
         }
         else
         {
-            view->list->setEintrag(index, zChild->getText());
-            view->list->setEintragPos(index, childIndex);
+            view->list->setEntry(index, zChild->getText());
+            view->list->setEntryPos(index, childIndex);
         }
         childIndex++;
     };
-    for (int i = 0; i < view->list->getEintragAnzahl(); i++)
+    for (int i = 0; i < view->list->getEntryCount(); i++)
     {
-        view->list->zEintrag(i)->setSchriftSize(20);
-        view->list->zEintrag(i)->setSchriftFarbe(0XFFFFFFFF);
-        view->list->zEintrag(i)->setRahmenFarbe(0xFF52525E);
+        view->list->zEntry(i)->setFontSize(20);
+        view->list->zEntry(i)->setFontColor(0XFFFFFFFF);
+        view->list->zEntry(i)->setBorderColor(0xFF52525E);
     }
     int auswahl
         = element.selectChildsByAttribute("selected")
@@ -79,14 +79,14 @@ bool ListViewElement::updateElement(Framework::XML::Element& element,
                       return child->zParent()->getChildIndex(child);
                   })
               .orElse(-1);
-    view->list->setAuswahl(auswahl);
+    view->list->setSelection(auswahl);
     view->lastSelection = auswahl;
     view->onSelected = element.getAttributeValue("onSelectMessage");
     return true;
 }
 
 void ListViewElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -96,52 +96,52 @@ void ListViewElement::layout(Framework::XML::Element& element,
     if (view)
     {
         Framework::Text height = element.getAttributeValue("member-height");
-        if (height.istGleich(""))
+        if (height.isEqual(""))
         {
             height = 30;
         }
-        for (int i = 0; i < view->list->getEintragAnzahl(); i++)
+        for (int i = 0; i < view->list->getEntryCount(); i++)
         {
-            view->list->zEintrag(i)->setHeight((int)height);
+            view->list->zEntry(i)->setHeight((int)height);
         }
-        view->list->setSize(view->getInnenBreite(), view->getInnenHeight());
-        if ((int)height * view->list->getEintragAnzahl() > view->getHeight())
+        view->list->setSize(view->getInnerWidth(), view->getInnerHeight());
+        if ((int)height * view->list->getEntryCount() > view->getHeight())
         {
-            view->list->addStyle(Framework::AuswahlListe::Style::VScroll);
-            view->list->setVertikalKlickScroll((int)height);
+            view->list->addStyle(Framework::SelectionList::Style::VScroll);
+            view->list->setVerticalClickScroll((int)height);
             view->list->updateVScroll();
         }
     }
 }
 
 ListView::ListView()
-    : Framework::Zeichnung(),
-      list(new Framework::AuswahlListe())
+    : Framework::Drawable(),
+      list(new Framework::SelectionList())
 {
-    addStyle(Framework::Zeichnung::Style::Sichtbar
-             | Framework::Zeichnung::Style::Erlaubt);
-    setMausEreignis(Framework::_ret1ME);
-    list->setStyle(Framework::AuswahlListe::Style::Normal);
-    list->setMausEreignis(Framework::_ret1ME);
-    list->setRahmenFarbe(0xFF52525E);
-    list->setRahmenBreite(1);
-    list->setALRBreite(2);
-    list->setALRFarbe(0xFF0018FF);
-    list->setAAFFarbe(0xA0337AB7);
-    list->setAAFStrength(5);
-    lastSelection = list->getAuswahl();
+    addStyle(Framework::Drawable::Style::Visible
+             | Framework::Drawable::Style::Allowed);
+    setMouseEvent(Framework::_ret1ME);
+    list->setStyle(Framework::SelectionList::Style::Normal);
+    list->setMouseEvent(Framework::_ret1ME);
+    list->setBorderColor(0xFF52525E);
+    list->setBorderWidth(1);
+    list->setSelectionBorderWidth(2);
+    list->setSelectionBorderColor(0xFF0018FF);
+    list->setSelectionAFColor(0xA0337AB7);
+    list->setSelectionAFStrength(5);
+    lastSelection = list->getSelection();
 }
 
 bool ListView::tick(double tickVal)
 {
     rend |= list->tick(tickVal);
-    int auswahl = list->getAuswahl();
+    int auswahl = list->getSelection();
     if (auswahl != lastSelection)
     {
         Framework::Text* dialogName
-            = onSelected.getTeilText(0, onSelected.positionVon(";"));
+            = onSelected.getTeilText(0, onSelected.positionOf(";"));
         Framework::Text* messageId
-            = onSelected.getTeilText(onSelected.positionVon(";") + 1);
+            = onSelected.getTeilText(onSelected.positionOf(";") + 1);
         char msg[6];
         msg[0] = 0; // element message
         msg[1] = (char)(int)*messageId;
@@ -151,12 +151,12 @@ bool ListView::tick(double tickVal)
         messageId->release();
         lastSelection = auswahl;
     }
-    return Zeichnung::tick(tickVal);
+    return Drawable::tick(tickVal);
 }
 
-void ListView::render(Framework::Bild& rObj)
+void ListView::render(Framework::Image& rObj)
 {
-    Zeichnung::render(rObj);
+    Drawable::render(rObj);
     if (rObj.setDrawOptions(pos, gr))
     {
         list->render(rObj);
@@ -164,16 +164,16 @@ void ListView::render(Framework::Bild& rObj)
     }
 }
 
-void ListView::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void ListView::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    bool vera = me.verarbeitet;
+    bool vera = me.processed;
     if (!userRet)
     {
-        me.verarbeitet = 1;
+        me.processed = 1;
     }
-    list->doPublicMausEreignis(me);
+    list->doPublicMouseEvent(me);
     if (!userRet)
     {
-        me.verarbeitet = vera;
+        me.processed = vera;
     }
 }

FactoryCraft/ListView.h

@@ -9,24 +9,24 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class ListView : public Framework::Zeichnung
+class ListView : public Framework::Drawable
 {
 private:
-    Framework::AuswahlListe* list;
+    Framework::SelectionList* list;
     Framework::RCArray<Framework::Text> ids;
     Framework::Text onSelected;
     int lastSelection;
@@ -35,8 +35,8 @@ public:
     ListView();
 
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 
     friend ListViewElement;
 };

FactoryCraft/Load.cpp

@@ -2,42 +2,42 @@
 
 #include <Array.h>
 #include <AsynchronCall.h>
-#include <Datei.h>
-#include <DateiSystem.h>
+#include <File.h>
+#include <FileSystem.h>
 #include <GraphicsApi.h>
-#include <M3Datei.h>
+#include <M3File.h>
 #include <Text.h>
-#include <Textur.h>
+#include <Texture.h>
 
 #include "FactoryClient.h"
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 #include "ServerSelection.h"
 
-LoadMenu::LoadMenu(Bildschirm* zScreen)
+LoadMenu::LoadMenu(Screen* zScreen)
     : Menu(zScreen)
 {
-    Punkt center = zScreen->getBackBufferSize() / 2;
-    all = initFBalken(
-        center.x - 100, center.y - 65, 200, 30, FBalken::Style::normal);
-    stageTitle = initTextFeld(center.x - 100,
+    Point center = zScreen->getBackBufferSize() / 2;
+    all = initProgressBar(
+        center.x - 100, center.y - 65, 200, 30, ProgressBar::Style::normal);
+    stageTitle = initTextField(center.x - 100,
         center.y - 30,
         zScreen->getBackBufferSize().x - center.x + 100,
         15,
-        TextFeld::Style::Text,
+        TextField::Style::Text,
         "");
-    stage = initFBalken(
-        center.x - 100, center.y - 15, 200, 30, FBalken::Style::normal);
-    stage->removeStyle(FBalken::Style::Sichtbar);
-    stepTitle = initTextFeld(center.x - 100,
+    stage = initProgressBar(
+        center.x - 100, center.y - 15, 200, 30, ProgressBar::Style::normal);
+    stage->removeStyle(ProgressBar::Style::Visible);
+    stepTitle = initTextField(center.x - 100,
         center.y + 20,
         zScreen->getBackBufferSize().x - center.x + 100,
         15,
-        TextFeld::Style::Text,
+        TextField::Style::Text,
         "");
-    step = initFBalken(
-        center.x - 100, center.y + 35, 200, 30, FBalken::Style::normal);
-    step->removeStyle(FBalken::Style::Sichtbar);
+    step = initProgressBar(
+        center.x - 100, center.y + 35, 200, 30, ProgressBar::Style::normal);
+    step->removeStyle(ProgressBar::Style::Visible);
     elements.add(step);
     elements.add(stepTitle);
     elements.add(stage);
@@ -47,37 +47,37 @@ LoadMenu::LoadMenu(Bildschirm* zScreen)
 
 void LoadMenu::stepProgress(int stepSize)
 {
-    step->aktionPlus(stepSize);
+    step->actionPlus(stepSize);
 }
 
 void LoadMenu::beginNextStep(const char* title, int nextStepSize)
 {
     stepTitle->setText(title);
-    step->setAktionAnzahl(nextStepSize);
+    step->setActionCount(nextStepSize);
     step->reset();
-    step->addStyle(FBalken::Style::Sichtbar);
+    step->addStyle(ProgressBar::Style::Visible);
 }
 
 void LoadMenu::stageProgress(int stepSize)
 {
-    stage->aktionPlus(stepSize);
-    step->removeStyle(FBalken::Style::Sichtbar);
+    stage->actionPlus(stepSize);
+    step->removeStyle(ProgressBar::Style::Visible);
 }
 
 void LoadMenu::beginNextStage(const char* title, int nextStageSize)
 {
     stageTitle->setText(title);
-    stage->setAktionAnzahl(nextStageSize);
+    stage->setActionCount(nextStageSize);
     stage->reset();
-    stage->addStyle(FBalken::Style::Sichtbar);
-    step->removeStyle(FBalken::Style::Sichtbar);
+    stage->addStyle(ProgressBar::Style::Visible);
+    step->removeStyle(ProgressBar::Style::Visible);
 }
 
 void LoadMenu::allProgress(int stepSize)
 {
-    all->aktionPlus(stepSize);
-    stage->removeStyle(FBalken::Style::Sichtbar);
-    step->removeStyle(FBalken::Style::Sichtbar);
+    all->actionPlus(stepSize);
+    stage->removeStyle(ProgressBar::Style::Visible);
+    step->removeStyle(ProgressBar::Style::Visible);
 }
 
 void LoadMenu::load(FactoryClient* client,
@@ -86,12 +86,12 @@ void LoadMenu::load(FactoryClient* client,
     unsigned short port,
     std::function<void(int, Text)> onFinish)
 {
-    all->setAktionAnzahl(9);
+    all->setActionCount(9);
     all->reset();
     stageTitle->setText("");
     stepTitle->setText("");
-    step->removeStyle(FBalken::Style::Sichtbar);
-    stage->removeStyle(FBalken::Style::Sichtbar);
+    step->removeStyle(ProgressBar::Style::Visible);
+    stage->removeStyle(ProgressBar::Style::Visible);
     new AsynchronCall(
         "Load Menu", [this, client, name, secret, port, onFinish]() {
             Text tmp = secret;
@@ -100,17 +100,17 @@ void LoadMenu::load(FactoryClient* client,
         });
 }
 
-Bild* loadImage(Framework::Text path)
+Image* loadImage(Framework::Text path)
 {
     if (path.beginnsWith("itemType:"))
     {
         Text* typeIdName = path.getTeilText(9);
         for (int i = 0; i < itemTypeCount; i++)
         {
-            if (itemTypes[i]->getName().istGleich(*typeIdName))
+            if (itemTypes[i]->getName().isEqual(*typeIdName))
             {
-                Bild* img
-                    = dynamic_cast<Bild*>(itemTypes[i]->zIcon()->getThis());
+                Image* img
+                    = dynamic_cast<Image*>(itemTypes[i]->zIcon()->getThis());
                 typeIdName->release();
                 return img;
             }
@@ -120,12 +120,11 @@ Bild* loadImage(Framework::Text path)
     }
     else
     {
-        LTDBDatei file;
-        file.setDatei(path.getTeilText(
-            0, path.positionVon("/", path.anzahlVon("/") - 1)));
-        file.leseDaten(0);
-        return file.laden(0,
-            path.getTeilText(
-                path.positionVon("/", path.anzahlVon("/") - 1) + 1));
+        LTDBFile file;
+        file.setFile(
+            path.getTeilText(0, path.positionOf("/", path.countOf("/") - 1)));
+        file.readData(0);
+        return file.load(0,
+            path.getTeilText(path.positionOf("/", path.countOf("/") - 1) + 1));
     }
 }

FactoryCraft/Load.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <Fortschritt.h>
-#include <TextFeld.h>
+#include <Progress.h>
+#include <TextField.h>
 
 #include "Menu.h"
 #undef LoadMenu
@@ -12,14 +12,14 @@ class FactoryClient;
 class LoadMenu : public Menu
 {
 private:
-    FBalken* step;
-    TextFeld* stepTitle;
-    FBalken* stage;
-    TextFeld* stageTitle;
-    FBalken* all;
+    ProgressBar* step;
+    TextField* stepTitle;
+    ProgressBar* stage;
+    TextField* stageTitle;
+    ProgressBar* all;
 
 public:
-    LoadMenu(Bildschirm* zScreen);
+    LoadMenu(Screen* zScreen);
     void load(FactoryClient* client,
         Text name,
         Text secret,
@@ -32,4 +32,4 @@ public:
     void allProgress(int stepSize);
 };
 
-Bild* loadImage(Framework::Text path);
+Image* loadImage(Framework::Text path);

FactoryCraft/Main.cpp

@@ -1,21 +1,21 @@
-#include <Bildschirm.h>
-#include <Datei.h>
-#include <DateiSystem.h>
-#include <Fenster.h>
+#include <Screen.h>
+#include <File.h>
+#include <FileSystem.h>
+#include <Window.h>
 #include <GraphicsApi.h>
 #include <HttpRequest.h>
 #include <JSON.h>
 #include <main.h>
 #include <Network.h>
 #include <RenderThread.h>
-#include <Schrift.h>
-#include <Textur.h>
+#include <Font.h>
+#include <Texture.h>
 
 #include "CustomDX11API.h"
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 
-void createModels(Bildschirm* zScreen);
+void createModels(Screen* zScreen);
 
 /* Test rendering of specific block types
 int KSGStart Framework::Start(Framework::Startparam p)
@@ -24,68 +24,68 @@ int KSGStart Framework::Start(Framework::Startparam p)
     initVariables();
     setDebugDX(1);
 
-    Datei d;
-    d.setDatei("data/schriften");
-    auto list = d.getDateiListe();
+    File d;
+    d.setFile("data/schriften");
+    auto list = d.getFileList();
     for (Text* fontFile : *list)
     {
-        LTDSDatei dat;
+        LTDSFile dat;
         dat.setPfad(
             new Text(Text("data/schriften/").operator+(fontFile->getText())));
-        dat.leseDaten();
+        dat.readData();
         Text* name = fontFile->getTeilText(0, fontFile->getLength() - 5);
-        fontRegister->put(*name, RCPointer<Schrift>::of(dat.ladeSchrift()));
+        fontRegister->put(*name, RCPointer<Font>::of(dat.loadFont()));
         name->release();
     }
     list->release();
 
-    WFenster window;
+    NativeWindow window;
     ::window = &window;
     WNDCLASS wc = Framework::F_Normal(p.hinst);
     wc.lpszClassName = "Factory Craft";
-    window.erstellen(WS_POPUPWINDOW, wc);
+    window.create(WS_POPUPWINDOW, wc);
     Monitor m = Framework::getMonitor(0);
-    window.setBounds(Punkt(m.x, m.y), Punkt(m.breite, m.height));
-    window.setAnzeigeModus(SW_SHOWNORMAL);
-    window.setVSchließAktion([&window](void* p, void* f) {
-        StopNachrichtenSchleife(window.getFensterHandle());
+    window.setBounds(Point(m.x, m.y), Point(m.width, m.height));
+    window.setDisplayMode(SW_SHOWNORMAL);
+    window.setPreCloseAction([&window](void* p, void* f) {
+        StopMessageLoop(window.getWindowHandle());
     });
-    window.setMausAktion(_ret1ME);
-    window.setTastaturAktion(_ret1TE);
-    Bildschirm3D screen(
-        dynamic_cast<WFenster*>(window.getThis()), new CustomDX11API());
+    window.setMouseAction(_ret1ME);
+    window.setKeyboardAction(_ret1TE);
+    Screen3D screen(
+        dynamic_cast<NativeWindow*>(window.getThis()), new CustomDX11API());
     screen.setHandleUserInputsOnTick(1);
-    window.setBildschirm(dynamic_cast<Bildschirm*>(screen.getThis()));
-    screen.setFillFarbe(0);
+    window.setScreen(dynamic_cast<Screen*>(screen.getThis()));
+    screen.setFillColor(0);
 
     uiFactory = Framework::defaultUI(fontRegister->get("normal"), &screen);
 
     createModels(&screen);
 
     // loading textures
-    Datei texturF;
-    texturF.setDatei("data/textures");
-    RCArray<Text>* files = texturF.getDateiListe();
+    File texturF;
+    texturF.setFile("data/textures");
+    RCArray<Text>* files = texturF.getFileList();
     if (files)
     {
         int count = 0;
         for (Text* fileName : *files)
         {
-            LTDBDatei dat;
-            dat.setDatei(new Text(Text("data/textures/") + *fileName));
-            dat.leseDaten(0);
-            count += dat.getBildAnzahl();
+            LTDBFile dat;
+            dat.setFile(new Text(Text("data/textures/") + *fileName));
+            dat.readData(0);
+            count += dat.getImageCount();
         }
         for (Text* fileName : *files)
         {
-            LTDBDatei dat;
-            dat.setDatei(new Text(Text("data/textures/") + *fileName));
-            dat.leseDaten(0);
-            for (Text* name : *dat.zBildListe())
+            LTDBFile dat;
+            dat.setFile(new Text(Text("data/textures/") + *fileName));
+            dat.readData(0);
+            for (Text* name : *dat.zImageListe())
             {
-                Bild* b = dat.laden(0, new Text(*name));
+                Image* b = dat.load(0, new Text(*name));
                 screen.zGraphicsApi()
-                    ->createOrGetTextur(*fileName + "/" + *name, b)
+                    ->createOrGetTexture(*fileName + "/" + *name, b)
                     ->release();
             }
         }
@@ -102,26 +102,26 @@ block type to render Block* b = type->createBlock(Vec3<float>(0, 0, 0));
     b->setLightData(SOUTH, light);
     b->setLightData(WEST, light);
     b->setLightData(BOTTOM, light);
-    Chunk *c = new Chunk(Punkt(0, 0));
+    Chunk *c = new Chunk(Point(0, 0));
     c->setBlock(b);
-    Welt3D* w = new Welt3D();
+    World3D* w = new World3D();
     w->addCollection(c);
-    Kam3D* kam = new Kam3D();
+    Cam3D* kam = new Cam3D();
     kam->setStyle(
-        Kam3D::Style::Movable | Kam3D::Style::Rotatable | Kam3D::Style::Tick);
+        Cam3D::Style::Movable | Cam3D::Style::Rotatable | Cam3D::Style::Tick);
     kam->setPosition(Vec3<float>(10, 0, 0));
     kam->setAusrichtung(Vec3<float>(0, 0, 0));
-    kam->setWelt(w);
+    kam->setWorld(w);
     screen.addKamera(kam);
 
     RenderTh rTh;
     rTh.setMaxFps(60);
     rTh.setQuiet(1);
-    rTh.setBildschirm(dynamic_cast<Bildschirm*>(screen.getThis()));
+    rTh.setScreen(dynamic_cast<Screen*>(screen.getThis()));
 
     rTh.beginn();
-    StartNachrichtenSchleife();
-    rTh.beenden();
+    StartMessageLoop();
+    rTh.terminate();
     releaseVariables();
     Network::Exit();
     return 0;
@@ -134,53 +134,53 @@ int KSGStart Framework::Start(Framework::Startparam p)
     initVariables();
     setDebugDX(1);
 
-    Datei d;
-    d.setDatei("data/schriften");
-    auto list = d.getDateiListe();
+    File d;
+    d.setFile("data/schriften");
+    auto list = d.getFileList();
     for (Text* fontFile : *list)
     {
-        LTDSDatei dat;
+        LTDSFile dat;
         dat.setPfad(
             new Text(Text("data/schriften/").operator+(fontFile->getText())));
-        dat.leseDaten();
+        dat.readData();
         Text* name = fontFile->getTeilText(0, fontFile->getLength() - 5);
-        fontRegister->put(*name, RCPointer<Schrift>::of(dat.ladeSchrift()));
+        fontRegister->put(*name, RCPointer<Font>::of(dat.loadFont()));
         name->release();
     }
     list->release();
 
-    WFenster window;
+    NativeWindow window;
     ::window = &window;
     WNDCLASS wc = Framework::F_Normal(p.hinst);
     wc.lpszClassName = "Factory Craft";
-    window.erstellen(WS_POPUPWINDOW, wc);
+    window.create(WS_POPUPWINDOW, wc);
     Monitor m = Framework::getMonitor(0);
-    window.setBounds(Punkt(m.x, m.y), Punkt(m.breite, m.height));
-    window.setAnzeigeModus(SW_SHOWNORMAL);
-    window.setVSchließAktion([&window](void* p, void* f) {
-        StopNachrichtenSchleife(window.getFensterHandle());
+    window.setBounds(Point(m.x, m.y), Point(m.width, m.height));
+    window.setDisplayMode(SW_SHOWNORMAL);
+    window.setPreCloseAction([&window](void* p, void* f) {
+        StopMessageLoop(window.getWindowHandle());
     });
-    window.setMausAktion(_ret1ME);
-    window.setTastaturAktion(_ret1TE);
-    Bildschirm3D screen(
-        dynamic_cast<WFenster*>(window.getThis()), new CustomDX11API());
+    window.setMouseAction(_ret1ME);
+    window.setKeyboardAction(_ret1TE);
+    Screen3D screen(
+        dynamic_cast<NativeWindow*>(window.getThis()), new CustomDX11API());
     screen.setHandleUserInputsOnTick(1);
-    window.setBildschirm(dynamic_cast<Bildschirm*>(screen.getThis()));
-    screen.setFillFarbe(0);
+    window.setScreen(dynamic_cast<Screen*>(screen.getThis()));
+    screen.setFillColor(0);
     screen.setTestRend(0);
 
     uiFactory = Framework::defaultUI(fontRegister->get("normal"), &screen);
-    uiFactory.createKnopf = createKnopf;
-    uiFactory.createTextFeld = createTextFeld;
-    uiFactory.createKontrollKnopf = createKontrollKnopf;
-    uiFactory.createObjTabelle = createObjTabelle;
-    uiFactory.createFenster = createFenster;
+    uiFactory.createButton = createButton;
+    uiFactory.createTextField = createTextField;
+    uiFactory.createCheckBox = createCheckBox;
+    uiFactory.createObjTable = createObjTable;
+    uiFactory.createWindow = createWindow;
     initMenus();
 
     RenderTh rTh;
     rTh.setMaxFps(-1);
     rTh.setQuiet(1);
-    rTh.setBildschirm(dynamic_cast<Bildschirm*>(screen.getThis()));
+    rTh.setScreen(dynamic_cast<Screen*>(screen.getThis()));
 
     rTh.setTickFunktion([](void* p, void* o, double time) {
         if (World::INSTANCE)
@@ -190,8 +190,8 @@ int KSGStart Framework::Start(Framework::Startparam p)
     });
 
     rTh.beginn();
-    StartNachrichtenSchleife();
-    rTh.beenden();
+    StartMessageLoop();
+    rTh.terminate();
 
     releaseVariables();
     Network::Exit();

FactoryCraft/MapOptions.cpp

@@ -1,116 +1,114 @@
 #include "MapOptions.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 
 MapOptions::MapOptions()
-    : Fenster()
+    : Window()
 {
-    Framework::LTDBDatei iconsDat;
-    iconsDat.setDatei(new Framework::Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    Framework::LTDBFile iconsDat;
+    iconsDat.setFile(new Framework::Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    setStyle(
-        Fenster::Style::Erlaubt | Fenster::Style::Rahmen
-        | Fenster::Style::BodyHAlpha | Fenster::Style::Titel
-        | Fenster::Style::TitelHAlpha | Fenster::Style::Closable
-        | Fenster::Style::ClosingHAlpha | Fenster::Style::ClosingKlickBuffer
-        | Fenster::Style::TitelHintergrund | Fenster::Style::BodyHintergrund
-        | Fenster::Style::ClosingHintergrund | Fenster::Style::MEIgnoreInside
-        | Fenster::Style::Beweglich | Style::ClosingHBild
-        | Style::ClosingBuffer);
-    removeStyle(Fenster::Style::Sichtbar);
+    setStyle(Window::Style::Allowed | Window::Style::Border
+             | Window::Style::BodyBAlpha | Window::Style::Title
+             | Window::Style::TitleBAlpha | Window::Style::Closable
+             | Window::Style::ClosingBAlpha | Window::Style::ClosingBuffer
+             | Window::Style::TitleBackground | Window::Style::BodyBackground
+             | Window::Style::ClosingBackground | Window::Style::MEIgnoreInside
+             | Window::Style::Movable | Style::ClosingBImage
+             | Style::ClosingBuffer);
+    removeStyle(Window::Style::Visible);
     setTitel("Map options");
-    setClosingMe([this](void* p, void* o, Framework::MausEreignis me) {
-        if (me.id == Framework::ME_RLinks)
+    setClosingMe([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == Framework::ME_RLeft)
         {
-            removeStyle(Fenster::Style::Sichtbar);
+            removeStyle(Window::Style::Visible);
         }
         return 1;
     });
     setSize(210, 125);
     setPosition(uiFactory.initParam.bildschirm->getBackBufferSize().x / 2
-                    - getBreite() / 2,
+                    - getWidth() / 2,
         uiFactory.initParam.bildschirm->getBackBufferSize().y / 2
             - getHeight() / 2);
-    setMausEreignis(Framework::_ret1ME);
-    setTastaturEreignis(Framework::_ret1TE);
-    setRBreite(1);
-    setRFarbe(0xFF52525E);
-    setKBgFarbe(0xA0000000);
-    setTBgFarbe(0xA0000000);
-    setSBgFarbe(0xA0000000);
-    setTSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    zTTextFeld()->setSize(0, 20);
-    zTTextFeld()->addStyle(TextFeld::Style::Center);
-    setSAfStrength(10);
-    setSAfFarbe(0x5F9C0A0A);
-    setSBgBildZ(iconsDat.laden(0, new Text("close.png")));
-    setSKAfFarbe(0xFF9C0A0A);
-    setSKAfStrength(10);
+    setMouseEvent(Framework::_ret1ME);
+    setKeyboardEvent(Framework::_ret1TE);
+    setBorderWidth(1);
+    setBorderColor(0xFF52525E);
+    setBodyBgColor(0xA0000000);
+    setTBgColor(0xA0000000);
+    setCloseBgColor(0xA0000000);
+    setTFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    zTTextField()->setSize(0, 20);
+    zTTextField()->addStyle(TextField::Style::Center);
+    setCloseAfStrength(10);
+    setCloseAfColor(0x5F9C0A0A);
+    setCloseBgImageZ(iconsDat.load(0, new Text("close.png")));
+    setCloseClickAfColor(0xFF9C0A0A);
+    setCloseClickAfStrength(10);
 
-    underground = initKontrollKnopf(5,
+    underground = initCheckBox(5,
         5,
         200,
         20,
-        Framework::KontrollKnopf::Style::Normal
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        Framework::CheckBox::Style::Normal
+            & ~Framework::CheckBox::Style::Border,
         "Show underground map");
-    underground->setNMausEreignis(_ret1ME);
+    underground->setPostMouseEvent(_ret1ME);
     addMember(underground);
 
-    followPlayer = initKontrollKnopf(5,
+    followPlayer = initCheckBox(5,
         30,
         200,
         20,
-        Framework::KontrollKnopf::Style::Normal
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        Framework::CheckBox::Style::Normal
+            & ~Framework::CheckBox::Style::Border,
         "Follow player");
-    followPlayer->setNMausEreignis(_ret1ME);
+    followPlayer->setPostMouseEvent(_ret1ME);
     addMember(followPlayer);
 
-    showPlayers = initKontrollKnopf(5,
+    showPlayers = initCheckBox(5,
         55,
         200,
         20,
-        (Framework::KontrollKnopf::Style::Normal
-            | Framework::KontrollKnopf::Style::Selected)
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        (Framework::CheckBox::Style::Normal
+            | Framework::CheckBox::Style::Selected)
+            & ~Framework::CheckBox::Style::Border,
         "Show Players");
-    showPlayers->setNMausEreignis(_ret1ME);
+    showPlayers->setPostMouseEvent(_ret1ME);
     addMember(showPlayers);
 
-    showChunkBorders = initKontrollKnopf(5,
+    showChunkBorders = initCheckBox(5,
         80,
         200,
         20,
-        (Framework::KontrollKnopf::Style::Normal
-            | Framework::KontrollKnopf::Style::Selected)
-            & ~Framework::KontrollKnopf::Style::Rahmen,
+        (Framework::CheckBox::Style::Normal
+            | Framework::CheckBox::Style::Selected)
+            & ~Framework::CheckBox::Style::Border,
         "Show Chunk Borders");
-    showChunkBorders->setNMausEreignis(_ret1ME);
+    showChunkBorders->setPostMouseEvent(_ret1ME);
     addMember(showChunkBorders);
 }
 
 bool MapOptions::isUnderground()
 {
-    return underground->hatStyle(KontrollKnopf::Style::Selected);
+    return underground->hasStyle(CheckBox::Style::Selected);
 }
 
 bool MapOptions::isFollowPlayer()
 {
-    return followPlayer->hatStyle(KontrollKnopf::Style::Selected);
+    return followPlayer->hasStyle(CheckBox::Style::Selected);
 }
 
 bool MapOptions::isShowPlayers()
 {
-    return showPlayers->hatStyle(KontrollKnopf::Style::Selected);
+    return showPlayers->hasStyle(CheckBox::Style::Selected);
 }
 
 bool MapOptions::isShowChunkBorders()
 {
-    return showChunkBorders->hatStyle(KontrollKnopf::Style::Selected);
+    return showChunkBorders->hasStyle(CheckBox::Style::Selected);
 }

FactoryCraft/MapOptions.h

@@ -2,15 +2,15 @@
 
 #include "OptionsWindow.h"
 
-#include <Knopf.h>
+#include <Button.h>
 
-class MapOptions : public Framework::Fenster
+class MapOptions : public Framework::Window
 {
 private:
-    Framework::KontrollKnopf* underground;
-    Framework::KontrollKnopf* followPlayer;
-    Framework::KontrollKnopf* showPlayers;
-    Framework::KontrollKnopf* showChunkBorders;
+    Framework::CheckBox* underground;
+    Framework::CheckBox* followPlayer;
+    Framework::CheckBox* showPlayers;
+    Framework::CheckBox* showChunkBorders;
     
 public:
     MapOptions();

FactoryCraft/MapWindow.cpp

@@ -1,16 +1,16 @@
 #include "MapWindow.h"
 
-#include <TextFeld.h>
+#include <TextField.h>
 
 #include "Globals.h"
 
 MapWindow::MapWindow()
-    : OptionsWindow([this]() { options->addStyle(Fenster::Style::Sichtbar); }),
+    : OptionsWindow([this]() { options->addStyle(Window::Style::Visible); }),
       map(0)
 {
     setTitel("Map");
-    setClosingMe([this](void* p, void* o, Framework::MausEreignis me) {
-        if (me.id == Framework::ME_RLinks)
+    setClosingMe([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == Framework::ME_RLeft)
         {
             setVisibility(0);
         }
@@ -18,15 +18,14 @@ MapWindow::MapWindow()
     });
     setSize(500, 500);
     setPosition(uiFactory.initParam.bildschirm->getBackBufferSize().x / 2
-                    - getBreite() / 2,
+                    - getWidth() / 2,
         uiFactory.initParam.bildschirm->getBackBufferSize().y / 2
             - getHeight() / 2);
-    setKMin(200, 200);
+    setBodyMin(200, 200);
     options = new MapOptions();
     options->getThis(); // increase reference counter outside of dynamic_cast to
                         // avoid compiler warning
-    uiFactory.initParam.bildschirm->addMember(
-        dynamic_cast<Zeichnung*>(options));
+    uiFactory.initParam.bildschirm->addMember(dynamic_cast<Drawable*>(options));
 }
 
 MapWindow::~MapWindow()
@@ -41,20 +40,20 @@ void MapWindow::setVisibility(bool visible)
         uiFactory.initParam.bildschirm->postAction([this, visible]() {
             if (visible && !map)
             {
-                lockZeichnung();
+                lockDrawable();
                 map = new DimensionMap(options);
-                map->setSize(getInnenBreite(), getInnenHeight());
+                map->setSize(getInnerWidth(), getInnerHeight());
                 addMember(map);
-                unlockZeichnung();
-                addStyle(Fenster::Style::Sichtbar);
+                unlockDrawable();
+                addStyle(Window::Style::Visible);
             }
             if (!visible && map)
             {
-                removeStyle(Fenster::Style::Sichtbar);
-                lockZeichnung();
+                removeStyle(Window::Style::Visible);
+                lockDrawable();
                 removeMember(map);
                 map = 0;
-                unlockZeichnung();
+                unlockDrawable();
             }
         });
     }
@@ -62,7 +61,7 @@ void MapWindow::setVisibility(bool visible)
 
 void MapWindow::addChunk(ChunkMap* chunk)
 {
-    lockZeichnung();
+    lockDrawable();
     if (map)
     {
         map->addChunk(chunk);
@@ -71,18 +70,18 @@ void MapWindow::addChunk(ChunkMap* chunk)
     {
         chunk->release();
     }
-    unlockZeichnung();
+    unlockDrawable();
 }
 
 void MapWindow::updatePlayerData(char* data)
 {
-    lockZeichnung();
+    lockDrawable();
     if (map) map->updatePlayers(data);
-    unlockZeichnung();
+    unlockDrawable();
 }
 
 bool MapWindow::tick(double time)
 {
-    if (map) map->setSize(getInnenBreite(), getInnenHeight());
+    if (map) map->setSize(getInnerWidth(), getInnerHeight());
     return OptionsWindow::tick(time);
 }

FactoryCraft/Menu.cpp

@@ -2,7 +2,7 @@
 
 #include <AsynchronCall.h>
 
-Menu::Menu(Bildschirm* zScreen)
+Menu::Menu(Screen* zScreen)
     : ReferenceCounter(),
       zScreen(zScreen)
 {}
@@ -10,13 +10,13 @@ Menu::Menu(Bildschirm* zScreen)
 void Menu::show()
 {
     for (auto member : elements)
-        zScreen->addMember(dynamic_cast<Zeichnung*>(member->getThis()));
+        zScreen->addMember(dynamic_cast<Drawable*>(member->getThis()));
 }
 
 void Menu::hide()
 {
     zScreen->postAction([this]() {
         for (auto member : elements)
-            zScreen->removeMember(dynamic_cast<Zeichnung*>(member->getThis()));
+            zScreen->removeMember(dynamic_cast<Drawable*>(member->getThis()));
     });
 }

FactoryCraft/Menu.h

@@ -1,18 +1,18 @@
 #pragma once
 #include <Array.h>
-#include <Bildschirm.h>
-#include <Zeichnung.h>
+#include <Screen.h>
+#include <Drawing.h>
 
 using namespace Framework;
 
 class Menu : public ReferenceCounter
 {
 protected:
-    RCArray<Zeichnung> elements;
-    Bildschirm* zScreen;
+    RCArray<Drawable> elements;
+    Screen* zScreen;
 
 public:
-    Menu(Bildschirm* zScreen);
+    Menu(Screen* zScreen);
 
     virtual void show();
     virtual void hide();

FactoryCraft/Menü.h

@@ -1,44 +1,45 @@
-#ifndef Menü_H
-#define Menü_H
+#ifndef Menu_H
+#define Menu_H
 
-#include <Knopf.h>
-#include <Tabelle.h>
-#include <Diagramm.h>
-#include <AuswahlBox.h>
+#include <Border.h>
+#include <Button.h>
+#include <Diagram.h>
 #include <KSGNetwork.h>
-#include <Rahmen.h>
+#include <SelectionBox.h>
+#include <Table.h>
 
 using namespace Framework;
 
-class Menü
+class Menu
 {
 private:
-	Knopf *spielen;
-	Knopf *optionen;
-	Knopf *statistik;
-	Knopf *beenden;
-	Bild *hintergrund;
-	LRahmen *ram;
-	bool beendet;
-	int status;
-	int ref;
+    Button* spielen;
+    Button* optionen;
+    Button* statistik;
+    Button* beenden;
+    Image* hintergrund;
+    LBorder* ram;
+    bool beendet;
+    int status;
+    int ref;
 
 public:
-	// Konstruktor
-	Menü( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
-	// Destruktor
-	~Menü();
-	// nicht constant#
-	void reset();
-	void doMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double z );
-	void render( Bild &zRObj );
-	// constant
-	bool istBeendet() const;
-	// Reference Counting
-	Menü *getThis();
-	Menü *release();
+    // Konstruktor
+    Menu2(
+        Font* zFont, Screen* zScreen, KSGClient::MinigameServerClient* klient);
+    // Destruktor
+    ~Menu();
+    // nicht constant#
+    void reset();
+    void doMouseEvent(MouseEvent& me);
+    void doKeyboardEvent(KeyboardEvent& te);
+    bool tick(double z);
+    void render(Image& zRObj);
+    // constant
+    bool istBeendet() const;
+    // Reference Counting
+    Menu* getThis();
+    Menu* release();
 };
 
 #endif

FactoryCraft/ModelInfo.cpp

@@ -1,6 +1,6 @@
 #include "ModelInfo.h"
 
-#include <Textur.h>
+#include <Texture.h>
 
 #include "Globals.h"
 
@@ -18,25 +18,25 @@ ModelInfo::ModelInfo(const char* model, const char *texture, bool transparent, i
 ModelInfo::ModelInfo(Framework::StreamReader* reader)
 {
     char len;
-    reader->lese(&len, 1);
+    reader->read(&len, 1);
     char* path = new char[len + 1];
-    reader->lese(path, len);
+    reader->read(path, len);
     path[len] = 0;
     modelPath = path;
     delete[] path;
     short count;
-    reader->lese((char*)&count, 2);
+    reader->read((char*)&count, 2);
     for (int i = 0; i < count; i++)
     {
-        reader->lese(&len, 1);
+        reader->read(&len, 1);
         path = new char[len + 1];
-        reader->lese(path, len);
+        reader->read(path, len);
         path[len] = 0;
         texturPaths.add(new Text(path));
         delete[] path;
     }
-    reader->lese((char*)&transparent, 1);
-    reader->lese((char*)&size, 4);
+    reader->read((char*)&transparent, 1);
+    reader->read((char*)&size, 4);
 }
 
 Framework::Model3DData* ModelInfo::getModel() const
@@ -44,18 +44,18 @@ Framework::Model3DData* ModelInfo::getModel() const
     return uiFactory.initParam.bildschirm->zGraphicsApi()->getModel(modelPath);
 }
 
-Framework::Model3DTextur* ModelInfo::getTexture() const
+Framework::Model3DTexture* ModelInfo::getTexture() const
 {
-    Model3DTextur* textur = new Model3DTextur();
+    Model3DTexture* texture = new Model3DTexture();
     int index = 0;
     for (Text* texturPath : texturPaths)
     {
-        Textur* tex
-            = uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTextur(
+        Texture* tex
+            = uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTexture(
                 texturPath->getText(), 0);
-        textur->setPolygonTextur(index++, tex);
+        texture->setPolygonTexture(index++, tex);
     }
-    return textur;
+    return texture;
 }
 
 Framework::Text ModelInfo::getModelName() const

FactoryCraft/ModelInfo.h

@@ -21,7 +21,7 @@ public:
     ModelInfo(Framework::StreamReader* reader);
 
     Framework::Model3DData* getModel() const;
-    Framework::Model3DTextur* getTexture() const;
+    Framework::Model3DTexture* getTexture() const;
     Framework::Text getModelName() const;
     const Framework::RCArray<Framework::Text>* getTexturNames() const;
     bool isTransparent() const;

FactoryCraft/OptionsWindow.cpp

@@ -1,58 +1,57 @@
 #include "OptionsWindow.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 
 OptionsWindow::OptionsWindow(std::function<void()> onOptionsOpen)
-    : Fenster(),
+    : Window(),
       onOptionsOpen(onOptionsOpen)
 {
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    setStyle(Style::Erlaubt | Style::Rahmen | Style::BodyHAlpha | Style::Titel
-             | Style::TitelHAlpha | Style::Closable | Style::ClosingHAlpha
-             | Style::CustomTitle | Style::ClosingBuffer
-             | Style::ClosingKlickBuffer | Style::ClosingHBild
-             | Style::TitelHintergrund | Style::BodyHintergrund
-             | Style::ClosingHintergrund | Style::MEIgnoreInside
-             | Style::HeightChangeable | Style::BreiteChangeable
-             | Style::BodyMinBr | Style::BodyMinHi | Style::Beweglich);
-    removeStyle(Style::Sichtbar);
-    setMausEreignis(Framework::_ret1ME);
-    setTastaturEreignis(Framework::_ret1TE);
-    setRBreite(1);
-    setRFarbe(0xFF52525E);
-    setKBgFarbe(0xA0000000);
-    setTBgFarbe(0xA0000000);
-    setSBgFarbe(0xA0000000);
-    setTSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    zTTextFeld()->setSize(0, 20);
-    zTTextFeld()->addStyle(TextFeld::Style::Center);
-    setSAfStrength(10);
-    setSAfFarbe(0x5F9C0A0A);
-    setSBgBildZ(iconsDat.laden(0, new Text("close.png")));
-    setSKAfFarbe(0xFF9C0A0A);
-    setSKAfStrength(10);
+    setStyle(Style::Allowed | Style::Border | Style::BodyBAlpha | Style::Title
+             | Style::TitleBAlpha | Style::Closable | Style::ClosingBAlpha
+             | Style::CustomTitle | Style::ClosingBuffer | Style::CustomTitle
+             | Style::ClosingBuffer | Style::ClosingBImage
+             | Style::TitleBackground | Style::BodyBackground
+             | Style::ClosingBackground | Style::MEIgnoreInside
+             | Style::HeightChangeable | Style::WidthChangeable
+             | Style::BodyMinWidth | Style::BodyMinHeight | Style::Movable);
+    removeStyle(Style::Visible);
+    setMouseEvent(Framework::_ret1ME);
+    setKeyboardEvent(Framework::_ret1TE);
+    setBorderWidth(1);
+    setBorderColor(0xFF52525E);
+    setBodyBgColor(0xA0000000);
+    setTBgColor(0xA0000000);
+    setCloseBgColor(0xA0000000);
+    setTFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    zTTextField()->setSize(0, 20);
+    zTTextField()->addStyle(TextField::Style::Center);
+    setCloseAfStrength(10);
+    setCloseAfColor(0x5F9C0A0A);
+    setCloseBgImageZ(iconsDat.load(0, new Text("close.png")));
+    setCloseClickAfColor(0xFF9C0A0A);
+    setCloseClickAfStrength(10);
 
-    optionsButton = initKnopf(0,
+    optionsButton = initButton(0,
         0,
         20,
         20,
-        Framework::Knopf::Style::HBild | Framework::Knopf::Style::HAlpha
-            | Framework::Knopf::Style::Hintergrund,
+        Framework::Button::Style::BImage | Framework::Button::Style::BAlpha
+            | Framework::Button::Style::Background,
         "");
-    optionsButton->setAlphaFeldFarbe(0x5F337AB7);
+    optionsButton->setAlphaFieldColor(0x5F337AB7);
     optionsButton->setToolTipText(
-        "Options", uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
-    optionsButton->setHintergrundBildZ(
-        iconsDat.laden(0, new Text("options.png")));
-    optionsButton->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        "Options", uiFactory.initParam.bildschirm, uiFactory.initParam.font);
+    optionsButton->setBackgroundImageZ(
+        iconsDat.load(0, new Text("options.png")));
+    optionsButton->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             this->onOptionsOpen();
         }
@@ -65,29 +64,29 @@ OptionsWindow::~OptionsWindow()
     optionsButton->release();
 }
 
-void OptionsWindow::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void OptionsWindow::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    optionsButton->doPublicMausEreignis(me);
-    Fenster::doMausEreignis(me, userRet);
+    optionsButton->doPublicMouseEvent(me);
+    Window::doMouseEvent(me, userRet);
 }
 
 bool OptionsWindow::tick(double time)
 {
     rend |= optionsButton->tick(time);
-    return Fenster::tick(time);
+    return Window::tick(time);
 }
 
-void OptionsWindow::render(Framework::Bild& rObj)
+void OptionsWindow::render(Framework::Image& rObj)
 {
-    if (!hatStyle(Style::Sichtbar)) return;
-    int titleHeight = zTTextFeld()->getHeight();
-    zTTextFeld()->setPosition(titleHeight, 0);
+    if (!hasStyle(Style::Visible)) return;
+    int titleHeight = zTTextField()->getHeight();
+    zTTextField()->setPosition(titleHeight, 0);
     int closingWidth = 0;
-    if (hatStyle(Style::Closable)) closingWidth = titleHeight;
-    zTTextFeld()->setWidth(getInnenBreite() - titleHeight - closingWidth);
-    Fenster::render(rObj);
+    if (hasStyle(Style::Closable)) closingWidth = titleHeight;
+    zTTextField()->setWidth(getInnerWidth() - titleHeight - closingWidth);
+    Window::render(rObj);
     optionsButton->setSize(titleHeight, titleHeight);
-    int rbr = getRBreite();
+    int rbr = getBorderWidth();
     if (!rObj.setDrawOptions(
             pos.x + rbr, pos.y + rbr, gr.x - rbr * 2, titleHeight))
     {

FactoryCraft/OptionsWindow.h

@@ -1,19 +1,19 @@
 #pragma once
 
-#include <Fenster.h>
-#include <Knopf.h>
+#include <Window.h>
+#include <Button.h>
 
-class OptionsWindow : public Framework::Fenster
+class OptionsWindow : public Framework::Window
 {
 private:
     std::function<void()> onOptionsOpen;
-    Framework::Knopf* optionsButton;
+    Framework::Button* optionsButton;
     
 public:
     OptionsWindow(std::function<void()> onOptionsOpen);
     ~OptionsWindow();
 
-    virtual void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    virtual void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
     virtual bool tick(double time) override;
-    virtual void render(Framework::Bild& rObj) override;
+    virtual void render(Framework::Image& rObj) override;
 };

FactoryCraft/PlayerKam.cpp

@@ -21,14 +21,14 @@ public:
     static const int GROUND_CONTACT = 0x01000;
 };
 
-PlayerKam::PlayerKam(Framework::Bildschirm3D* zScreen)
-    : Kam3D()
+PlayerKam::PlayerKam(Framework::Screen3D* zScreen)
+    : Cam3D()
 {
     kameraControll = 0;
-    setBildschirmPosition(0, 0);
-    setBildschirmSize(zScreen->getBackBufferSize());
+    setScreenPosition(0, 0);
+    setScreenSize(zScreen->getBackBufferSize());
     setStyle(
-        Kam3D::Style::Tick | Kam3D::Style::Movable | Kam3D::Style::Rotatable);
+        Cam3D::Style::Tick | Cam3D::Style::Movable | Cam3D::Style::Rotatable);
     setRotation({(float)PI / 2.f, 0, 0});
     lastDirection = {0, 0, 0};
     entityId = -1;
@@ -45,7 +45,7 @@ void PlayerKam::setDirection(Framework::Vec3<float> direction)
     }
 }
 
-void PlayerKam::doTastaturEreignis(Framework::TastaturEreignis& te)
+void PlayerKam::doKeyboardEvent(Framework::KeyboardEvent& te)
 {
     if (!World::INSTANCE)
     {
@@ -53,11 +53,11 @@ void PlayerKam::doTastaturEreignis(Framework::TastaturEreignis& te)
     }
     if (te.id == TE_Press)
     {
-        if (te.taste[0] >= '0' && te.taste[0] <= '9')
+        if (te.key[0] >= '0' && te.key[0] <= '9')
         {
             char action[5];
             action[0] = 3;
-            *(int*)(action + 1) = te.taste[0] - '1';
+            *(int*)(action + 1) = te.key[0] - '1';
             if (*(int*)(action + 1) < 0) *(int*)(action + 1) = 9;
             World::INSTANCE->zClient()->sendPlayerAction(action, 5);
         }
@@ -109,12 +109,12 @@ void PlayerKam::doTastaturEreignis(Framework::TastaturEreignis& te)
             char action = 4; // open inventory
             World::INSTANCE->zClient()->sendPlayerAction(&action, 1);
         }
-        if (te.taste[0] == 'q')
+        if (te.key[0] == 'q')
         {
             char action = 9; // open quest dialog
             World::INSTANCE->zClient()->sendPlayerAction(&action, 1);
         }
-        if (te.taste[0] == 'm')
+        if (te.key[0] == 'm')
         {
             ((Game*)(Menu*)menuRegister->get("game"))->zMap()->setVisibility(1);
         }
@@ -146,7 +146,7 @@ void PlayerKam::doTastaturEreignis(Framework::TastaturEreignis& te)
         {
             movementFlags &= ~MovementFlags::SNEAKING;
         }
-        if (te.taste[0] == 'F')
+        if (te.key[0] == 'F')
         {
             if (movementFlags & MovementFlags::FLYING)
             {
@@ -165,13 +165,13 @@ void PlayerKam::doTastaturEreignis(Framework::TastaturEreignis& te)
     }
 }
 
-void PlayerKam::doMausEreignis(Framework::MausEreignis& me)
+void PlayerKam::doMouseEvent(Framework::MouseEvent& me)
 {
     if (!World::INSTANCE)
     {
         return;
     }
-    if (me.verarbeitet && me.id != ME_RLinks && me.id != ME_RRechts)
+    if (me.processed && me.id != ME_RLeft && me.id != ME_RRight)
     {
         kameraControll = 0;
         setShowCursor(true);
@@ -179,37 +179,37 @@ void PlayerKam::doMausEreignis(Framework::MausEreignis& me)
     }
     else
     {
-        if (!kameraControll && me.id != ME_RLinks && me.id != ME_RRechts)
+        if (!kameraControll && me.id != ME_RLeft && me.id != ME_RRight)
         {
-            if (me.id == ME_PLinks) setControlEnabled(1);
+            if (me.id == ME_PLeft) setControlEnabled(1);
         }
         else
         {
-            if (kameraControll || me.id == ME_RLinks || me.id == ME_RRechts)
+            if (kameraControll || me.id == ME_RLeft || me.id == ME_RRight)
             {
-                if (me.id == ME_PLinks)
+                if (me.id == ME_PLeft)
                 {
                     char action[2] = {1, 8};
                     World::INSTANCE->zClient()->sendPlayerAction(action, 2);
                 }
-                if (me.id == ME_RLinks)
+                if (me.id == ME_RLeft)
                 {
                     char action[2] = {0, 8};
                     World::INSTANCE->zClient()->sendPlayerAction(action, 2);
                 }
-                if (me.id == ME_PRechts)
+                if (me.id == ME_PRight)
                 {
                     char action[2] = {1, 9};
                     World::INSTANCE->zClient()->sendPlayerAction(action, 2);
                 }
-                if (me.id == ME_RRechts)
+                if (me.id == ME_RRight)
                 {
                     char action[2] = {0, 9};
                     World::INSTANCE->zClient()->sendPlayerAction(action, 2);
                 }
             }
         }
-        me.verarbeitet = 1;
+        me.processed = 1;
     }
     if (lastMovementFlags != movementFlags)
     {
@@ -225,16 +225,16 @@ bool PlayerKam::tick(double time)
         return 1;
     }
     __int64 style = 0;
-    if (hatStyle(Style::Movable)) style |= Style::Movable;
-    if (hatStyle(Style::Rotatable)) style |= Style::Rotatable;
-    if (hatStyle(Style::Zoomable)) style |= Style::Zoomable;
+    if (hasStyle(Style::Movable)) style |= Style::Movable;
+    if (hasStyle(Style::Rotatable)) style |= Style::Rotatable;
+    if (hasStyle(Style::Zoomable)) style |= Style::Zoomable;
     removeStyle(Style::Movable | Style::Rotatable | Style::Zoomable);
-    bool result = Kam3D::tick(time);
+    bool result = Cam3D::tick(time);
     addStyle(style);
     if (kameraControll)
     {
-        Punkt dir
-            = window->getGröße() / 2 - (getMausPos() - window->getPosition());
+        Point dir
+            = window->getSize() / 2 - (getMousePos() - window->getPosition());
         setRotation(
             {min(max(getRotation().x - dir.y * (float)time * 0.2f, 0.4f), 3.1f),
                 getRotation().y,
@@ -247,10 +247,10 @@ bool PlayerKam::tick(double time)
             setRotation({getRotation().x,
                 getRotation().y,
                 getRotation().z + 2.f * (float)PI});
-        SetCursorPos(window->getPosition().x + window->getKörperGröße().x / 2,
-            window->getPosition().y + window->getKörperGröße().y / 2);
+        SetCursorPos(window->getPosition().x + window->getBodySize().x / 2,
+            window->getPosition().y + window->getBodySize().y / 2);
         setShowCursor(false);
-        setMausPos(window->getPosition() + window->getGröße() / 2);
+        setMousePos(window->getPosition() + window->getSize() / 2);
     }
     Vec3<float> direction = getDirection();
     if (direction != lastDirection)
@@ -272,8 +272,8 @@ void PlayerKam::setControlEnabled(bool enabled)
     setShowCursor(!kameraControll);
     if (kameraControll)
     {
-        SetCursorPos(window->getPosition().x + window->getKörperGröße().x / 2,
-            window->getPosition().y + window->getKörperGröße().y / 2);
+        SetCursorPos(window->getPosition().x + window->getBodySize().x / 2,
+            window->getPosition().y + window->getBodySize().y / 2);
     }
 }
 

FactoryCraft/PlayerKam.h

@@ -1,11 +1,11 @@
 #pragma once
-#include <Bildschirm.h>
-#include <Kam3D.h>
-#include <TastaturEreignis.h>
+#include <Screen.h>
+#include <Camera3D.h>
+#include <KeyboardEvent.h>
 #include <Vec3.h>
-#include <Zeit.h>
+#include <Timer.h>
 
-class PlayerKam : public Framework::Kam3D
+class PlayerKam : public Framework::Cam3D
 {
 private:
     bool kameraControll;
@@ -15,10 +15,10 @@ private:
     int lastMovementFlags;
 
 public:
-    PlayerKam(Framework::Bildschirm3D* zScreen);
+    PlayerKam(Framework::Screen3D* zScreen);
     void setDirection(Framework::Vec3<float> direction);
-    void doTastaturEreignis(Framework::TastaturEreignis& te) override;
-    void doMausEreignis(Framework::MausEreignis& me) override;
+    void doKeyboardEvent(Framework::KeyboardEvent& te) override;
+    void doMouseEvent(Framework::MouseEvent& me) override;
     bool tick(double time) override;
     void setEntityId(int id);
     void setControlEnabled(bool enabled);

FactoryCraft/QuestGraph.cpp

@@ -1,7 +1,7 @@
 #include "QuestGraph.h"
 
-#include <Bild.h>
 #include <HashMap.h>
+#include <Image.h>
 #include <Scroll.h>
 #include <XML.h>
 
@@ -13,10 +13,10 @@ QuestGraphElement::QuestGraphElement() {}
 
 bool QuestGraphElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("questGraph");
+    return element.getName().isEqual("questGraph");
 }
 
-Framework::Zeichnung* QuestGraphElement::parseElement(
+Framework::Drawable* QuestGraphElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     QuestGraph* graph = new QuestGraph();
@@ -29,7 +29,7 @@ Framework::Zeichnung* QuestGraphElement::parseElement(
     // parse graph elements
     for (Framework::XML::Element* itemElement : children)
     {
-        Framework::Zeichnung* parsed
+        Framework::Drawable* parsed
             = generalFactory.parseElement(*itemElement, generalFactory);
         QuestGraphItem* item = dynamic_cast<QuestGraphItem*>(parsed);
         if (!item)
@@ -45,7 +45,7 @@ Framework::Zeichnung* QuestGraphElement::parseElement(
         }
         generalFactory.layout(*itemElement,
             *parsed,
-            graph->getBreite(),
+            graph->getWidth(),
             graph->getHeight(),
             generalFactory);
     }
@@ -59,11 +59,11 @@ Framework::Zeichnung* QuestGraphElement::parseElement(
         {
             connectionId++;
             Framework::Text* part = 0;
-            if (requirements.hat("||"))
+            if (requirements.has("||"))
             {
                 part = requirements.getTeilText(
-                    0, requirements.positionVon("||"));
-                requirements.remove(0, requirements.positionVon("||") + 2);
+                    0, requirements.positionOf("||"));
+                requirements.remove(0, requirements.positionOf("||") + 2);
             }
             else
             {
@@ -73,10 +73,10 @@ Framework::Zeichnung* QuestGraphElement::parseElement(
             while (part->getLength() > 0)
             {
                 Framework::Text* requirement;
-                if (part->hat("&&"))
+                if (part->has("&&"))
                 {
-                    requirement = part->getTeilText(0, part->positionVon("&&"));
-                    part->remove(0, part->positionVon("&&") + 2);
+                    requirement = part->getTeilText(0, part->positionOf("&&"));
+                    part->remove(0, part->positionOf("&&") + 2);
                 }
                 else
                 {
@@ -124,14 +124,14 @@ Framework::Zeichnung* QuestGraphElement::parseElement(
 }
 
 bool QuestGraphElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
 void QuestGraphElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -145,10 +145,10 @@ QuestGraphItemElement::QuestGraphItemElement() {}
 
 bool QuestGraphItemElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("questGraphItem");
+    return element.getName().isEqual("questGraphItem");
 }
 
-Framework::Zeichnung* QuestGraphItemElement::parseElement(
+Framework::Drawable* QuestGraphItemElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     QuestGraphItem* item = new QuestGraphItem();
@@ -156,18 +156,18 @@ Framework::Zeichnung* QuestGraphItemElement::parseElement(
     Framework::Text description = element.getAttributeValue("description");
     item->setToolTipText(name + "\n" + description,
         generalFactory.getFactory().initParam.bildschirm,
-        generalFactory.getFactory().initParam.schrift);
-    item->setHintergrundBildZ(loadImage(element.getAttributeValue("image")));
+        generalFactory.getFactory().initParam.font);
+    item->setBackgroundImageZ(loadImage(element.getAttributeValue("image")));
     item->finished = (int)element.getAttributeValue("finished") != 0;
     if (item->finished)
     {
-        item->setRahmenFarbe(0xFF55FF00);
+        item->setBorderColor(0xFF55FF00);
     }
     item->rewarded = (int)element.getAttributeValue("rewarded") != 0;
     item->mainQuest = (int)element.getAttributeValue("mainQuest") != 0;
     if (item->mainQuest)
     {
-        item->setRahmenBreite(3);
+        item->setBorderWidth(3);
     }
     item->id = element.getAttributeValue("id");
     item->requirements = element.getAttributeValue("requirements");
@@ -176,14 +176,14 @@ Framework::Zeichnung* QuestGraphItemElement::parseElement(
 }
 
 bool QuestGraphItemElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
 void QuestGraphItemElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -199,42 +199,42 @@ Connection::Connection(QuestGraphItem* zSource)
       maxY(0)
 {}
 
-void Connection::renderVertical(Framework::Bild& rObj)
+void Connection::renderVertical(Framework::Image& rObj)
 {
-    if (targets.getEintragAnzahl())
+    if (targets.getEntryCount())
     {
-        rObj.drawLinieV(
+        rObj.drawLineV(
             vx, minY, maxY - minY, isActive() ? 0xFFFFFFFF : 0xFF52525E);
     }
 }
 
-void Connection::renderHorizontal(Framework::Bild& rObj)
+void Connection::renderHorizontal(Framework::Image& rObj)
 {
-    if (targets.getEintragAnzahl())
+    if (targets.getEntryCount())
     {
-        Framework::Punkt start = zSource->getPosition();
-        start.x += zSource->getBreite();
+        Framework::Point start = zSource->getPosition();
+        start.x += zSource->getWidth();
         start.y += zSource->getHeight() / 2;
-        rObj.drawLinieH(start.x, start.y - 2, vx - start.x, 0xA0000000);
-        rObj.drawLinieH(start.x, start.y - 1, vx - start.x, 0xA0000000);
-        rObj.drawLinieH(start.x,
+        rObj.drawLineH(start.x, start.y - 2, vx - start.x, 0xA0000000);
+        rObj.drawLineH(start.x, start.y - 1, vx - start.x, 0xA0000000);
+        rObj.drawLineH(start.x,
             start.y,
             vx - start.x,
             isActive() ? 0xFFFFFFFF : 0xFF52525E);
-        rObj.drawLinieH(start.x, start.y + 1, vx - start.x, 0xA0000000);
-        rObj.drawLinieH(start.x, start.y + 2, vx - start.x, 0xA0000000);
+        rObj.drawLineH(start.x, start.y + 1, vx - start.x, 0xA0000000);
+        rObj.drawLineH(start.x, start.y + 2, vx - start.x, 0xA0000000);
         for (const ConnectionTarget& target : targets)
         {
-            Framework::Punkt end
+            Framework::Point end
                 = target.zTarget->getTargetPosition(target.targetIndex);
-            rObj.drawLinieH(vx + 1, end.y - 2, end.x - vx - 1, 0xA0000000);
-            rObj.drawLinieH(vx + 1, end.y - 1, end.x - vx - 1, 0xA0000000);
-            rObj.drawLinieH(vx + 1,
+            rObj.drawLineH(vx + 1, end.y - 2, end.x - vx - 1, 0xA0000000);
+            rObj.drawLineH(vx + 1, end.y - 1, end.x - vx - 1, 0xA0000000);
+            rObj.drawLineH(vx + 1,
                 end.y,
                 end.x - vx - 1,
                 isActive() ? 0xFFFFFFFF : 0xFF52525E);
-            rObj.drawLinieH(vx + 1, end.y + 1, end.x - vx - 1, 0xA0000000);
-            rObj.drawLinieH(vx + 1, end.y + 2, end.x - vx - 1, 0xA0000000);
+            rObj.drawLineH(vx + 1, end.y + 1, end.x - vx - 1, 0xA0000000);
+            rObj.drawLineH(vx + 1, end.y + 2, end.x - vx - 1, 0xA0000000);
         }
     }
 }
@@ -268,7 +268,7 @@ void Connection::layout()
     bool start = 1;
     for (const ConnectionTarget& target : targets)
     {
-        Framework::Punkt end
+        Framework::Point end
             = target.zTarget->getTargetPosition(target.targetIndex);
         if (start || end.y < minY)
         {
@@ -280,8 +280,8 @@ void Connection::layout()
         }
         start = 0;
     }
-    Framework::Punkt origin = zSource->getPosition();
-    origin.x += zSource->getBreite();
+    Framework::Point origin = zSource->getPosition();
+    origin.x += zSource->getWidth();
     origin.y += zSource->getHeight() / 2;
     if (minY > origin.y) minY = origin.y;
     if (maxY < origin.y) maxY = origin.y;
@@ -300,7 +300,7 @@ int Connection::getOrderNum() const
 
 int Connection::getTargetCount() const
 {
-    return targets.getEintragAnzahl();
+    return targets.getEntryCount();
 }
 
 int Connection::getVerticalLength() const
@@ -326,15 +326,14 @@ bool Connection::hasTarget(AndNode* zAndNode, int index) const
 }
 
 AndNode::AndNode()
-    : ZeichnungHintergrund()
+    : DrawableBackground()
 {
-    setStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Rahmen);
-    setRahmenBreite(1);
-    setRahmenFarbe(0xFF52525E);
-    tr.setSchriftSize(12);
-    tr.setSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
+    setStyle(
+        DrawableBackground::Style::Visible | DrawableBackground::Style::Border);
+    setBorderWidth(1);
+    setBorderColor(0xFF52525E);
+    tr.setFontSize(12);
+    tr.setFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
 }
 
 void AndNode::addConnection(Connection* zConnection)
@@ -355,30 +354,30 @@ void AndNode::addConnection(Connection* zConnection)
     }
 }
 
-void AndNode::render(Framework::Bild& rObj)
+void AndNode::render(Framework::Image& rObj)
 {
-    setRahmenFarbe(isActive() ? 0xFFFFFFFF : 0xFF52525E);
-    if (connections.getEintragAnzahl() > 1)
+    setBorderColor(isActive() ? 0xFFFFFFFF : 0xFF52525E);
+    if (connections.getEntryCount() > 1)
     {
-        ZeichnungHintergrund::render(rObj);
-        if (rObj.setDrawOptions(pos.x + getRahmenBreite(),
-                pos.y + getRahmenBreite(),
-                getInnenBreite(),
-                getInnenHeight()))
+        DrawableBackground::render(rObj);
+        if (rObj.setDrawOptions(pos.x + getBorderWidth(),
+                pos.y + getBorderWidth(),
+                getInnerWidth(),
+                getInnerHeight()))
         {
-            tr.renderText(getInnenBreite() / 2 - tr.getTextBreite("&") / 2,
-                getInnenHeight() / 2 - tr.getTextHeight("&") / 2,
+            tr.renderText(getInnerWidth() / 2 - tr.getTextWidth("&") / 2,
+                getInnerHeight() / 2 - tr.getTextHeight("&") / 2,
                 "&",
                 rObj,
                 isActive() ? 0xFFFFFFFF : 0xFF52525E);
             rObj.releaseDrawOptions();
         }
     }
-    else if (connections.getEintragAnzahl() > 0)
+    else if (connections.getEntryCount() > 0)
     {
         if (rObj.setDrawOptions(pos, gr))
         {
-            rObj.drawLinieH(0,
+            rObj.drawLineH(0,
                 0,
                 gr.x,
                 connections.get(0)->isActive() ? 0xFFFFFFFF : 0xFF52525E);
@@ -387,24 +386,24 @@ void AndNode::render(Framework::Bild& rObj)
     }
 }
 
-Framework::Punkt AndNode::getTargetPosition(int index)
+Framework::Point AndNode::getTargetPosition(int index)
 {
-    if (connections.getEintragAnzahl() == 1)
+    if (connections.getEntryCount() == 1)
     {
         return pos;
     }
-    return pos + Framework::Punkt(0, 10 + index * 11);
+    return pos + Framework::Point(0, 10 + index * 11);
 }
 
 void AndNode::layout()
 {
-    if (connections.getEintragAnzahl() == 1)
+    if (connections.getEntryCount() == 1)
     {
         setSize(20, 1);
     }
     else
     {
-        setSize(20, 10 + connections.getEintragAnzahl() * 11);
+        setSize(20, 10 + connections.getEntryCount() * 11);
     }
 }
 
@@ -414,12 +413,12 @@ bool AndNode::isActive() const
     {
         if (!connection->isActive()) return false;
     }
-    return connections.getEintragAnzahl() > 0;
+    return connections.getEntryCount() > 0;
 }
 
 int AndNode::getConnectionCount() const
 {
-    return connections.getEintragAnzahl();
+    return connections.getEntryCount();
 }
 
 OrConnection::OrConnection(QuestGraphItem* zTarget,
@@ -443,21 +442,21 @@ OrConnection::OrConnection(QuestGraphItem* zTarget,
     }
 }
 
-void OrConnection::render(Framework::Bild& rObj)
+void OrConnection::render(Framework::Image& rObj)
 {
-    if (andNodes.getEintragAnzahl() == 0) return;
+    if (andNodes.getEntryCount() == 0) return;
     bool active = isActive();
-    rObj.drawLinieV(zTarget->getX() - 11,
+    rObj.drawLineV(zTarget->getX() - 11,
         minY,
         maxY - minY,
         active ? 0xFFFFFFFF : 0xFF52525E);
-    rObj.drawLinieH(zTarget->getX() - 10,
+    rObj.drawLineH(zTarget->getX() - 10,
         zTarget->getY() + zTarget->getHeight() / 2,
         10,
         active ? 0xFFFFFFFF : 0xFF52525E);
     for (AndNode* node : andNodes)
     {
-        rObj.drawLinieH(node->getX() + node->getBreite(),
+        rObj.drawLineH(node->getX() + node->getWidth(),
             node->getY() + node->getHeight() / 2,
             10,
             active ? 0xFFFFFFFF : 0xFF52525E);
@@ -478,7 +477,7 @@ void OrConnection::layout()
     AndNode* last = 0;
     for (AndNode* node : andNodes)
     {
-        node->setPosition(zTarget->getX() - 21 - node->getBreite(), y);
+        node->setPosition(zTarget->getX() - 21 - node->getWidth(), y);
         if (start)
         {
             minY = y + node->getHeight() / 2;
@@ -534,10 +533,10 @@ bool OrConnection::isHorizontalLineConflict(
     {
         for (int i = 0; i < node->getConnectionCount(); i++)
         {
-            if (!zIgnoredIncommingConnection || !zIgnoredIncommingConnection
-                    ->hasTarget(node, i))
+            if (!zIgnoredIncommingConnection
+                || !zIgnoredIncommingConnection->hasTarget(node, i))
             {
-                Punkt connection = node->getTargetPosition(i);
+                Point connection = node->getTargetPosition(i);
                 if (abs(y - connection.y) < 5) return 1;
             }
         }
@@ -546,7 +545,7 @@ bool OrConnection::isHorizontalLineConflict(
 }
 
 QuestGraphItem::QuestGraphItem()
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       layerIndex(-1),
       nodeIndex(-1),
       outgoingConnection(0),
@@ -557,16 +556,15 @@ QuestGraphItem::QuestGraphItem()
       virtualNode(0),
       animationProgress(0)
 {
-    addStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Rahmen
-             | ZeichnungHintergrund::Style::Erlaubt
-             | ZeichnungHintergrund::Style::HBild
-             | ZeichnungHintergrund::Style::HBildScale
-             | ZeichnungHintergrund::Style::HAlpha
-             | ZeichnungHintergrund::Style::Hintergrund);
-    setRahmenFarbe(0xFF52525E);
-    setRahmenBreite(1);
-    setMausEreignis(Framework::_ret1ME);
+    addStyle(
+        DrawableBackground::Style::Visible | DrawableBackground::Style::Border
+        | DrawableBackground::Style::Allowed | DrawableBackground::Style::BImage
+        | DrawableBackground::Style::BImageScale
+        | DrawableBackground::Style::BAlpha
+        | DrawableBackground::Style::Background);
+    setBorderColor(0xFF52525E);
+    setBorderWidth(1);
+    setMouseEvent(Framework::_ret1ME);
 }
 
 QuestGraphItem::~QuestGraphItem()
@@ -578,12 +576,12 @@ QuestGraphItem::~QuestGraphItem()
 bool QuestGraphItem::tick(double tickVal)
 {
     animationProgress += tickVal * 20;
-    if (animationProgress > getBreite() * 2 + getHeight() * 2 - 4)
+    if (animationProgress > getWidth() * 2 + getHeight() * 2 - 4)
     {
-        animationProgress -= getBreite() * 2 + getHeight() * 2 - 4;
+        animationProgress -= getWidth() * 2 + getHeight() * 2 - 4;
     }
     rend = 1;
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
 int getBorderX(int p, int width, int height)
@@ -626,16 +624,16 @@ int getBorderY(int p, int width, int height)
     }
 }
 
-void QuestGraphItem::render(Framework::Bild& rObj)
+void QuestGraphItem::render(Framework::Image& rObj)
 {
     if (incommingConnection) incommingConnection->render(rObj);
     if (isVirtual())
     {
-        rObj.drawLinieH(
+        rObj.drawLineH(
             pos.x, pos.y, gr.x, isFinished() ? 0xFFFFFFFF : 0xFF52525E);
         return;
     }
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (finished && !rewarded)
     {
         if (rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y))
@@ -716,12 +714,12 @@ void QuestGraphItem::render(Framework::Bild& rObj)
     }
 }
 
-void QuestGraphItem::renderVerticalConnections(Framework::Bild& rObj)
+void QuestGraphItem::renderVerticalConnections(Framework::Image& rObj)
 {
     if (outgoingConnection) outgoingConnection->renderVertical(rObj);
 }
 
-void QuestGraphItem::renderHorizontalConnections(Framework::Bild& rObj)
+void QuestGraphItem::renderHorizontalConnections(Framework::Image& rObj)
 {
     if (outgoingConnection) outgoingConnection->renderHorizontal(rObj);
 }
@@ -771,7 +769,7 @@ void QuestGraphItem::setVirtual(bool virtualNode)
     this->virtualNode = virtualNode;
     gr.y = virtualNode ? 1 : gr.y;
     gr.x = 1;
-    setStyle(ZeichnungHintergrund::Style::Sichtbar, virtualNode);
+    setStyle(DrawableBackground::Style::Visible, virtualNode);
 }
 
 void QuestGraphItem::setNodeIndex(int index)
@@ -845,7 +843,7 @@ bool QuestGraphItemLayer::tick(double tickVal)
     return result;
 }
 
-void QuestGraphItemLayer::render(Framework::Bild& rObj)
+void QuestGraphItemLayer::render(Framework::Image& rObj)
 {
     for (QuestGraphItem* item : items)
     {
@@ -858,24 +856,24 @@ void QuestGraphItemLayer::render(Framework::Bild& rObj)
     }
 }
 
-void QuestGraphItemLayer::doMausEreignis(Framework::MausEreignis& me)
+void QuestGraphItemLayer::doMouseEvent(Framework::MouseEvent& me)
 {
     for (QuestGraphItem* item : items)
     {
-        item->doPublicMausEreignis(me);
+        item->doPublicMouseEvent(me);
     }
 }
 
 void QuestGraphItemLayer::addItem(QuestGraphItem* item)
 {
     items.add(item);
-    item->setNodeIndex(items.getEintragAnzahl() - 1);
+    item->setNodeIndex(items.getEntryCount() - 1);
 }
 
 bool QuestGraphItemLayer::sortItems()
 {
     bool changed = 0;
-    for (int index = 0; index < items.getEintragAnzahl() - 1; index++)
+    for (int index = 0; index < items.getEntryCount() - 1; index++)
     {
         QuestGraphItem* current = items.z(index);
         int conflicts = 0;
@@ -905,7 +903,7 @@ bool QuestGraphItemLayer::sortItems()
             QuestGraphItem* after = items.z(index + 1);
             after->setNodeIndex(index);
             current->setNodeIndex(index + 1);
-            items.tausch(index, index + 1);
+            items.swap(index, index + 1);
             changed = 1;
         }
     }
@@ -920,9 +918,9 @@ int QuestGraphItemLayer::fixItemPositions(int x)
     {
         item->initializeConnections();
         item->zIncommingConnection()->layout();
-        if (item->getBreite() > maxWidth)
+        if (item->getWidth() > maxWidth)
         {
-            maxWidth = item->getBreite();
+            maxWidth = item->getWidth();
         }
     }
     x += 20 + 21; // ofset for incomming connections
@@ -934,7 +932,7 @@ int QuestGraphItemLayer::fixItemPositions(int x)
         int lastId = -1;
         int nodeHeight = item->zIncommingConnection()->getNeededHeight();
         if (nodeHeight < item->getHeight()) nodeHeight = item->getHeight();
-        item->setPosition(x + maxWidth / 2 - item->getBreite() / 2,
+        item->setPosition(x + maxWidth / 2 - item->getWidth() / 2,
             y + nodeHeight / 2 - item->getHeight() / 2);
         y += nodeHeight + 20;
     }
@@ -945,8 +943,8 @@ int QuestGraphItemLayer::fixItemPositions(int x)
         item->zOutgoingConnection()->setVx(x);
         item->zOutgoingConnection()->layout();
     }
-    x += items.getEintragAnzahl() * 11 + 10; // offset for outgoing connections
-    return x + 20;                           // min space between layers
+    x += items.getEntryCount() * 11 + 10; // offset for outgoing connections
+    return x + 20;                        // min space between layers
 }
 
 void QuestGraphItemLayer::sortConnections()
@@ -957,8 +955,8 @@ void QuestGraphItemLayer::sortConnections()
         item->zOutgoingConnection()->layout();
     }
     int connectionCount = 0;
-    bool* sorted = new bool[items.getEintragAnzahl()];
-    memset(sorted, 0, sizeof(bool) * items.getEintragAnzahl());
+    bool* sorted = new bool[items.getEntryCount()];
+    memset(sorted, 0, sizeof(bool) * items.getEntryCount());
     int sortedCount = 0;
     while (true)
     {
@@ -982,7 +980,7 @@ void QuestGraphItemLayer::sortConnections()
         }
         if (!next)
         {
-            if (sortedCount < items.getEintragAnzahl())
+            if (sortedCount < items.getEntryCount())
             {
                 connectionCount++;
             }
@@ -1047,7 +1045,8 @@ void QuestGraphItemLayer::resolveHorizontalConflicts(
     for (QuestGraphItem* item : items)
     {
         int outgoingY = item->getY() + item->getHeight() / 2;
-        if (zNextLayer->isHorizontalLineConflict(outgoingY, item->zOutgoingConnection()))
+        if (zNextLayer->isHorizontalLineConflict(
+                outgoingY, item->zOutgoingConnection()))
         {
             int offset = 0;
             for (int i = 1; i <= 10; i++)
@@ -1085,14 +1084,14 @@ bool QuestGraphItemLayer::isHorizontalLineConflict(
 }
 
 QuestGraph::QuestGraph()
-    : ZeichnungHintergrund()
+    : DrawableBackground()
 {
-    addStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Erlaubt
-             | ZeichnungHintergrund::Style::Rahmen);
-    setRahmenBreite(1);
-    setRahmenFarbe(0xFF52525E);
-    setMausEreignis(Framework::_ret1ME);
+    addStyle(DrawableBackground::Style::Visible
+             | DrawableBackground::Style::Allowed
+             | DrawableBackground::Style::Border);
+    setBorderWidth(1);
+    setBorderColor(0xFF52525E);
+    setMouseEvent(Framework::_ret1ME);
 }
 
 bool QuestGraph::tick(double tickVal)
@@ -1101,30 +1100,30 @@ bool QuestGraph::tick(double tickVal)
     {
         rend |= layer->tick(tickVal);
     }
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void QuestGraph::render(Framework::Bild& rObj)
+void QuestGraph::render(Framework::Image& rObj)
 {
-    if (hatStyle(ZeichnungHintergrund::Style::Sichtbar)
-        && layers.getEintragAnzahl() > 0)
+    if (hasStyle(DrawableBackground::Style::Visible)
+        && layers.getEntryCount() > 0)
     {
-        ZeichnungHintergrund::render(rObj);
+        DrawableBackground::render(rObj);
         if (rObj.setDrawOptions(pos, gr))
         {
-            if (rObj.setDrawOptions(getRahmenBreite(),
-                    getRahmenBreite(),
-                    getInnenBreite(),
-                    getInnenHeight()))
+            if (rObj.setDrawOptions(getBorderWidth(),
+                    getBorderWidth(),
+                    getInnerWidth(),
+                    getInnerHeight()))
             {
                 int hScrollOffset = 0;
-                if (hatStyle(ZeichnungHintergrund::Style::HScroll)
+                if (hasStyle(DrawableBackground::Style::HScroll)
                     && horizontalScrollBar)
                 {
                     hScrollOffset = horizontalScrollBar->getScroll();
                 }
                 int vScrollOffset = 0;
-                if (hatStyle(ZeichnungHintergrund::Style::VScroll)
+                if (hasStyle(DrawableBackground::Style::VScroll)
                     && vertikalScrollBar)
                 {
                     vScrollOffset = vertikalScrollBar->getScroll();
@@ -1144,21 +1143,21 @@ void QuestGraph::render(Framework::Bild& rObj)
     }
 }
 
-void QuestGraph::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void QuestGraph::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    userRet &= hatStyle(ZeichnungHintergrund::Style::Sichtbar);
-    bool vera = me.verarbeitet;
+    userRet &= hasStyle(DrawableBackground::Style::Visible);
+    bool vera = me.processed;
     if (!userRet)
     {
-        me.verarbeitet = 1;
+        me.processed = 1;
     }
     for (QuestGraphItemLayer* layer : layers)
     {
-        layer->doMausEreignis(me);
+        layer->doMouseEvent(me);
     }
     if (!userRet)
     {
-        me.verarbeitet = vera;
+        me.processed = vera;
     }
 }
 
@@ -1170,7 +1169,7 @@ void QuestGraph::addVirtualConnectionNodes()
     // immediate following layer
     for (QuestGraphItemLayer* layer : layers)
     {
-        for (int i = 0; i < layer->getItems().getEintragAnzahl(); i++)
+        for (int i = 0; i < layer->getItems().getEntryCount(); i++)
         {
             QuestGraphItem* item = layer->getItems().z(i);
             auto iterator = item->getNextLayersConnections().begin();
@@ -1249,21 +1248,21 @@ void QuestGraph::fixItemPositions()
     {
         layer->sortConnections();
     }
-    if (height > getInnenHeight())
+    if (height > getInnerHeight())
     {
-        addStyle(ZeichnungHintergrund::Style::VScroll);
-        setVertikalKlickScroll(10);
-        vertikalScrollBar->update(height, getInnenHeight());
+        addStyle(DrawableBackground::Style::VScroll);
+        setVerticalClickScroll(10);
+        vertikalScrollBar->update(height, getInnerHeight());
     }
-    if (layers.getEintragAnzahl() * 150 - 80 > getInnenBreite())
+    if (layers.getEntryCount() * 150 - 80 > getInnerWidth())
     {
-        addStyle(ZeichnungHintergrund::Style::HScroll);
-        setHorizontalKlickScroll(10);
+        addStyle(DrawableBackground::Style::HScroll);
+        setHorizontalClickScroll(10);
         horizontalScrollBar->update(
-            layers.getEintragAnzahl() * 150 - 80, getInnenBreite());
+            layers.getEntryCount() * 150 - 80, getInnerWidth());
     }
     QuestGraphItemLayer* last = 0;
-    for (int i = layers.getEintragAnzahl() - 1; i >= 0; i--)
+    for (int i = layers.getEntryCount() - 1; i >= 0; i--)
     {
         QuestGraphItemLayer* layer = layers.z(i);
         layer->centerVertically(getHeight() / 2);
@@ -1282,21 +1281,21 @@ void QuestGraph::centerVertically()
             height = layer->getLeyerHeight();
         }
     }
-    if (height > getInnenHeight())
+    if (height > getInnerHeight())
     {
-        addStyle(ZeichnungHintergrund::Style::VScroll);
-        setVertikalKlickScroll(10);
-        vertikalScrollBar->update(height, getInnenHeight());
+        addStyle(DrawableBackground::Style::VScroll);
+        setVerticalClickScroll(10);
+        vertikalScrollBar->update(height, getInnerHeight());
     }
-    if (layers.getEintragAnzahl() * 150 - 80 > getInnenBreite())
+    if (layers.getEntryCount() * 150 - 80 > getInnerWidth())
     {
-        addStyle(ZeichnungHintergrund::Style::HScroll);
-        setHorizontalKlickScroll(10);
+        addStyle(DrawableBackground::Style::HScroll);
+        setHorizontalClickScroll(10);
         horizontalScrollBar->update(
-            layers.getEintragAnzahl() * 150 - 80, getInnenBreite());
+            layers.getEntryCount() * 150 - 80, getInnerWidth());
     }
     QuestGraphItemLayer* last = 0;
-    for (int i = layers.getEintragAnzahl() - 1; i >= 0; i--)
+    for (int i = layers.getEntryCount() - 1; i >= 0; i--)
     {
         QuestGraphItemLayer* layer = layers.z(i);
         layer->centerVertically(getHeight() / 2);
@@ -1310,7 +1309,7 @@ void QuestGraph::addItem(QuestGraphItem* item)
     int layerInex = item->getLayerIndex();
     if (layerInex >= 0)
     {
-        while (layerInex >= layers.getEintragAnzahl())
+        while (layerInex >= layers.getEntryCount())
         {
             layers.add(new QuestGraphItemLayer());
         }

FactoryCraft/QuestGraph.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Schrift.h>
+#include <Font.h>
 #include <UIMLView.h>
 
 #include "NetworkAPIProcessor.h"
@@ -12,15 +12,15 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
@@ -33,15 +33,15 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
@@ -74,8 +74,8 @@ private:
 
 public:
     Connection(QuestGraphItem* zSource);
-    void renderVertical(Framework::Bild& rObj);
-    void renderHorizontal(Framework::Bild& rObj);
+    void renderVertical(Framework::Image& rObj);
+    void renderHorizontal(Framework::Image& rObj);
     void setVx(int vx);
     void addConnectionTarget(ConnectionTarget target);
     void setTargetIndex(AndNode* zTarget, int index);
@@ -88,7 +88,7 @@ public:
     bool hasTarget(AndNode* zAndNode, int index) const;
 };
 
-class AndNode : public Framework::ZeichnungHintergrund
+class AndNode : public Framework::DrawableBackground
 {
 private:
     Framework::Array<Connection*> connections;
@@ -97,8 +97,8 @@ private:
 public:
     AndNode();
     void addConnection(Connection* zConnection);
-    void render(Framework::Bild& rObj);
-    Framework::Punkt getTargetPosition(int index);
+    void render(Framework::Image& rObj);
+    Framework::Point getTargetPosition(int index);
     void layout();
     bool isActive() const;
     int getConnectionCount() const;
@@ -115,7 +115,7 @@ private:
 public:
     OrConnection(QuestGraphItem* zTarget,
         const Framework::Array<ConnectionInfo>& connections);
-    void render(Framework::Bild& rObj);
+    void render(Framework::Image& rObj);
     void layout();
     int getNeededHeight() const;
     bool isActive() const;
@@ -123,7 +123,7 @@ public:
         int y, Connection* zIgnoredIncommingConnection) const;
 };
 
-class QuestGraphItem : public Framework::ZeichnungHintergrund
+class QuestGraphItem : public Framework::DrawableBackground
 {
 private:
     int layerIndex;
@@ -146,9 +146,9 @@ public:
     ~QuestGraphItem();
 
     bool tick(double tickVal);
-    void render(Framework::Bild& rObj);
-    void renderVerticalConnections(Framework::Bild& rObj);
-    void renderHorizontalConnections(Framework::Bild& rObj);
+    void render(Framework::Image& rObj);
+    void renderVerticalConnections(Framework::Image& rObj);
+    void renderHorizontalConnections(Framework::Image& rObj);
     void replacePreviousConnections(
         QuestGraphItem* zBefore, QuestGraphItem* zAfter);
     const Framework::Text& getId() const;
@@ -183,8 +183,8 @@ public:
     QuestGraphItemLayer();
 
     bool tick(double tickVal);
-    void render(Framework::Bild& rObj);
-    void doMausEreignis(Framework::MausEreignis& me);
+    void render(Framework::Image& rObj);
+    void doMouseEvent(Framework::MouseEvent& me);
 
     void addItem(QuestGraphItem* item);
 
@@ -200,7 +200,7 @@ public:
         int y, Connection* zIgnoredIncommingConnection) const;
 };
 
-class QuestGraph : public Framework::ZeichnungHintergrund
+class QuestGraph : public Framework::DrawableBackground
 {
 private:
     Framework::Text id;
@@ -212,8 +212,8 @@ public:
     QuestGraph();
 
     bool tick(double tickVal);
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 
     void addVirtualConnectionNodes();
     void sortItems();

FactoryCraft/RecipieGroup.cpp

@@ -1,44 +1,44 @@
 #include "RecipieGroup.h"
 
-#include <Bild.h>
-#include <Schrift.h>
+#include <Image.h>
+#include <Font.h>
 
 #include "Globals.h"
 
 RecipieGroup::RecipieGroup()
-    : Framework::ZeichnungHintergrund()
+    : Framework::DrawableBackground()
 {
-    setStyle(Framework::Zeichnung::Style::Erlaubt
-             | Framework::Zeichnung::Style::Sichtbar);
+    setStyle(Framework::Drawable::Style::Allowed
+             | Framework::Drawable::Style::Visible);
     icon = 0;
-    previousPage = uiFactory.createKnopf(uiFactory.initParam);
+    previousPage = uiFactory.createButton(uiFactory.initParam);
     previousPage->setText("<");
     previousPage->setToolTipText("Previous Page",
         uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
+        uiFactory.initParam.font);
     previousPage->setSize(20, 20);
     previousPage->setPosition(0, 0);
     previousPage->setStyle(
-        Framework::Knopf::Style::Normal & ~Framework::Knopf::Style::Sichtbar);
-    previousPage->setMausEreignis([this](void* p, void* z, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        Framework::Button::Style::Normal & ~Framework::Button::Style::Visible);
+    previousPage->setMouseEvent([this](void* p, void* z, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             currentPage--;
         }
         return 1;
     });
 
-    nextPage = uiFactory.createKnopf(uiFactory.initParam);
+    nextPage = uiFactory.createButton(uiFactory.initParam);
     nextPage->setText(">");
     nextPage->setToolTipText("Next Page",
         uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
+        uiFactory.initParam.font);
     nextPage->setSize(20, 20);
     nextPage->setPosition(0, 0);
     nextPage->setStyle(
-        Framework::Knopf::Style::Normal & ~Framework::Knopf::Style::Sichtbar);
-    nextPage->setMausEreignis([this](void* p, void* z, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        Framework::Button::Style::Normal & ~Framework::Button::Style::Visible);
+    nextPage->setMouseEvent([this](void* p, void* z, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             currentPage++;
         }
@@ -53,12 +53,12 @@ RecipieGroup::~RecipieGroup()
     nextPage->release();
 }
 
-void RecipieGroup::addRecipie(Framework::Zeichnung* recipie)
+void RecipieGroup::addRecipie(Framework::Drawable* recipie)
 {
     recipies.add(recipie);
 }
 
-void RecipieGroup::setIcon(Framework::Bild* icon)
+void RecipieGroup::setIcon(Framework::Image* icon)
 {
     if (this->icon) this->icon->release();
     this->icon = icon;
@@ -74,41 +74,41 @@ bool RecipieGroup::tick(double tickVal)
     int pi = 1;
     int y = 20;
     bool first = 1;
-    for (Zeichnung* recipie : recipies)
+    for (Drawable* recipie : recipies)
     {
         if (recipie->getHeight() + y > getHeight() && !first)
         {
             pi++;
             y = 20;
         }
-        recipie->setStyle(Zeichnung::Style::Sichtbar, pi == currentPage);
-        recipie->setX(getBreite() / 2 - recipie->getBreite() / 2);
+        recipie->setStyle(Drawable::Style::Visible, pi == currentPage);
+        recipie->setX(getWidth() / 2 - recipie->getWidth() / 2);
         recipie->setY(y);
         y += recipie->getHeight() + 50;
         first = 0;
         rend |= recipie->tick(tickVal);
     }
-    nextPage->setX(getBreite() - 20);
+    nextPage->setX(getWidth() - 20);
     maxPage = pi;
     currentPage = MAX(1, MIN(pi, currentPage));
-    previousPage->setStyle(Knopf::Style::Sichtbar, currentPage > 1);
-    nextPage->setStyle(Knopf::Style::Sichtbar, currentPage < maxPage);
+    previousPage->setStyle(Button::Style::Visible, currentPage > 1);
+    nextPage->setStyle(Button::Style::Visible, currentPage < maxPage);
     rend |= previousPage->tick(tickVal);
     rend |= nextPage->tick(tickVal);
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void RecipieGroup::render(Framework::Bild& rObj)
+void RecipieGroup::render(Framework::Image& rObj)
 {
-    if (!hatStyle(Zeichnung::Style::Sichtbar)) return;
-    ZeichnungHintergrund::render(rObj);
+    if (!hasStyle(Drawable::Style::Visible)) return;
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
-    Framework::TextRenderer tr(dynamic_cast<Framework::Schrift*>(uiFactory.initParam.schrift->getThis()));
-    tr.setSchriftSize(12);
+    Framework::TextRenderer tr(dynamic_cast<Framework::Font*>(uiFactory.initParam.font->getThis()));
+    tr.setFontSize(12);
     Text t = Text("Recipie page ") + Text(currentPage) + Text(" of ") + Text(maxPage);
-    int tbr = tr.getTextBreite(t);
-    tr.renderText(getBreite() / 2 - tbr / 2, 4, t, rObj, 0xFFFFFFFF);
-    for (Framework::Zeichnung* recipie : recipies)
+    int tbr = tr.getTextWidth(t);
+    tr.renderText(getWidth() / 2 - tbr / 2, 4, t, rObj, 0xFFFFFFFF);
+    for (Framework::Drawable* recipie : recipies)
     {
         recipie->render(rObj);
     }
@@ -117,17 +117,17 @@ void RecipieGroup::render(Framework::Bild& rObj)
     rObj.releaseDrawOptions();
 }
 
-void RecipieGroup::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void RecipieGroup::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    previousPage->doPublicMausEreignis(me);
-    nextPage->doPublicMausEreignis(me);
-    for (Zeichnung* recipie : recipies)
+    previousPage->doPublicMouseEvent(me);
+    nextPage->doPublicMouseEvent(me);
+    for (Drawable* recipie : recipies)
     {
-        recipie->doPublicMausEreignis(me);
+        recipie->doPublicMouseEvent(me);
     }
 }
 
-Framework::Bild* RecipieGroup::zIcon() const
+Framework::Image* RecipieGroup::zIcon() const
 {
     return icon;
 }

FactoryCraft/RecipieGroup.h

@@ -1,17 +1,17 @@
 #pragma once
 
 #include <Array.h>
-#include <Zeichnung.h>
-#include <Knopf.h>
+#include <Drawing.h>
+#include <Button.h>
 
-class RecipieGroup : public Framework::ZeichnungHintergrund
+class RecipieGroup : public Framework::DrawableBackground
 {
 private:
-    Framework::Bild* icon;
-    Framework::RCArray<Framework::Zeichnung> recipies;
+    Framework::Image* icon;
+    Framework::RCArray<Framework::Drawable> recipies;
     Framework::Text toolTip;
-    Framework::Knopf* previousPage;
-    Framework::Knopf* nextPage;
+    Framework::Button* previousPage;
+    Framework::Button* nextPage;
     int currentPage;
     int maxPage;
 
@@ -19,14 +19,14 @@ public:
     RecipieGroup();
     ~RecipieGroup();
 
-    void addRecipie(Framework::Zeichnung* recipie);
-    void setIcon(Framework::Bild* icon);
+    void addRecipie(Framework::Drawable* recipie);
+    void setIcon(Framework::Image* icon);
     void setToolTip(Framework::Text toolTip);
 
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 
-    Framework::Bild* zIcon() const;
+    Framework::Image* zIcon() const;
     Framework::Text getToolTip() const;
 };

FactoryCraft/RecipieIngredient.cpp

@@ -1,6 +1,6 @@
 #include "RecipieIngredient.h"
 
-#include <DateiSystem.h>
+#include <FileSystem.h>
 #include <ToolTip.h>
 #include <XML.h>
 
@@ -12,30 +12,30 @@ RecipieIngredientElement::RecipieIngredientElement()
 
 LogicTree* RecipieIngredientElement::parse(Framework::XML::Element* zElement)
 {
-    if (zElement->getName().istGleich("anyItem"))
+    if (zElement->getName().isEqual("anyItem"))
     {
         return new LogicTree(LogicalOperator::OR, new RequirementSet());
     }
-    else if (zElement->getName().istGleich("attribute"))
+    else if (zElement->getName().isEqual("attribute"))
     {
         AttributeOperator op = AttributeOperator::Equals;
-        if (zElement->getAttributeValue("operator").istGleich("!="))
+        if (zElement->getAttributeValue("operator").isEqual("!="))
         {
             op = AttributeOperator::NotEquals;
         }
-        else if (zElement->getAttributeValue("operator").istGleich(">"))
+        else if (zElement->getAttributeValue("operator").isEqual(">"))
         {
             op = AttributeOperator::GreaterThan;
         }
-        else if (zElement->getAttributeValue("operator").istGleich(">="))
+        else if (zElement->getAttributeValue("operator").isEqual(">="))
         {
             op = AttributeOperator::GreaterThanOrEquals;
         }
-        else if (zElement->getAttributeValue("operator").istGleich("<"))
+        else if (zElement->getAttributeValue("operator").isEqual("<"))
         {
             op = AttributeOperator::LessThan;
         }
-        else if (zElement->getAttributeValue("operator").istGleich("<="))
+        else if (zElement->getAttributeValue("operator").isEqual("<="))
         {
             op = AttributeOperator::LessThanOrEquals;
         }
@@ -47,7 +47,7 @@ LogicTree* RecipieIngredientElement::parse(Framework::XML::Element* zElement)
         req->release();
         return new LogicTree(LogicalOperator::OR, set);
     }
-    else if (zElement->getName().istGleich("operator"))
+    else if (zElement->getName().isEqual("operator"))
     {
         bool result0_0 = (bool)(int)zElement->getAttributeValue("result_0_0");
         bool result0_1 = (bool)(int)zElement->getAttributeValue("result_0_1");
@@ -196,15 +196,15 @@ LogicTree* RecipieIngredientElement::parse(Framework::XML::Element* zElement)
     return 0;
 }
 
-//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
+//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
 //! ist
 bool RecipieIngredientElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("ingredient");
+    return element.getName().isEqual("ingredient");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* RecipieIngredientElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* RecipieIngredientElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     int amount = (int)element.getAttributeValue("amount");
@@ -231,15 +231,15 @@ Framework::Zeichnung* RecipieIngredientElement::parseElement(
 }
 
 bool RecipieIngredientElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void RecipieIngredientElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -250,37 +250,37 @@ void RecipieIngredientElement::layout(Framework::XML::Element& element,
 }
 
 RecipieIngredient::RecipieIngredient(int amount)
-    : Framework::ZeichnungHintergrund(),
+    : Framework::DrawableBackground(),
       currentIconIndex(0),
       timtUntilNextIcon(2.0),
       amount(amount)
 {
-    setStyle(Framework::Zeichnung::Style::Erlaubt
-             | Framework::Zeichnung::Style::Sichtbar);
-    Framework::ToolTip* tip = new Framework::ToolTip(window->zBildschirm());
-    tip->addStyle(Framework::ZeichnungHintergrund::Style::Hintergrund
-                  | Framework::ZeichnungHintergrund::Style::HAlpha
-                  | Framework::ZeichnungHintergrund::Style::Rahmen
-                  | Framework::ZeichnungHintergrund::Style::Sichtbar);
-    tip->setHintergrundFarbe(0xA0000000);
-    tip->setRahmenFarbe(0xFFFFFFFF);
-    tip->setRahmenBreite(1);
-    toolTip = uiFactory.createTextFeld(uiFactory.initParam);
+    setStyle(Framework::Drawable::Style::Allowed
+             | Framework::Drawable::Style::Visible);
+    Framework::ToolTip* tip = new Framework::ToolTip(window->zScreen());
+    tip->addStyle(Framework::DrawableBackground::Style::Background
+                  | Framework::DrawableBackground::Style::BAlpha
+                  | Framework::DrawableBackground::Style::Border
+                  | Framework::DrawableBackground::Style::Visible);
+    tip->setBackgroundColor(0xA0000000);
+    tip->setBorderColor(0xFFFFFFFF);
+    tip->setBorderWidth(1);
+    toolTip = uiFactory.createTextField(uiFactory.initParam);
     toolTip->setText("");
     toolTip->setSize(0, 0);
-    toolTip->addStyle(Framework::TextFeld::Style::Mehrzeilig);
+    toolTip->addStyle(Framework::TextField::Style::Multiline);
     tip->addMember(toolTip);
     tip->setWarten(0.5);
     setToolTipZ(tip);
 }
 
 void RecipieIngredient::addPossibleItem(
-    Framework::Bild* icon, Framework::Text* toolTip, int typeId)
+    Framework::Image* icon, Framework::Text* toolTip, int typeId)
 {
     icons.add(icon);
     toolTips.add(toolTip);
     itemTypes.add(typeId);
-    if (toolTips.getEintragAnzahl() == 1)
+    if (toolTips.getEntryCount() == 1)
     {
         this->toolTip->setText(toolTips.z(0)->getText());
         this->toolTip->setSize(
@@ -297,11 +297,11 @@ bool RecipieIngredient::tick(double tickVal)
         {
             timtUntilNextIcon = 2.0;
             currentIconIndex++;
-            if (currentIconIndex >= icons.getEintragAnzahl())
+            if (currentIconIndex >= icons.getEntryCount())
             {
                 currentIconIndex = 0;
             }
-            if (toolTips.getEintragAnzahl() > 0)
+            if (toolTips.getEntryCount() > 0)
             {
                 toolTip->setText(toolTips.z(currentIconIndex)->getText());
                 toolTip->setSize(
@@ -310,20 +310,19 @@ bool RecipieIngredient::tick(double tickVal)
             }
         }
     }
-    return ZeichnungHintergrund::tick(tickVal);
+    return DrawableBackground::tick(tickVal);
 }
 
-void RecipieIngredient::render(Framework::Bild& rObj)
+void RecipieIngredient::render(Framework::Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     TextRenderer tr;
-    tr.setSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    tr.setSchriftSize(12);
+    tr.setFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    tr.setFontSize(12);
     rObj.fillRegion(0, 0, 50, 50, 0xFF222222);
-    if (icons.getEintragAnzahl() > 0)
-        rObj.alphaBild(0, 0, 50, 50, *icons.z(currentIconIndex));
+    if (icons.getEntryCount() > 0)
+        rObj.alphaImage(0, 0, 50, 50, *icons.z(currentIconIndex));
     const char* units[] = {"", "K", "M", "G", "T", "P"};
     int i = 0;
     int tmpCount = amount;
@@ -331,7 +330,7 @@ void RecipieIngredient::render(Framework::Bild& rObj)
         tmpCount = tmpCount / 1024;
     Text count = tmpCount;
     count += units[i];
-    tr.renderText(45 - tr.getTextBreite(count),
+    tr.renderText(45 - tr.getTextWidth(count),
         45 - tr.getTextHeight(count),
         count,
         rObj,
@@ -339,18 +338,17 @@ void RecipieIngredient::render(Framework::Bild& rObj)
     rObj.releaseDrawOptions();
 }
 
-void RecipieIngredient::doMausEreignis(
-    Framework::MausEreignis& me, bool userRet)
+void RecipieIngredient::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    if (me.id == ME_RLinks)
+    if (me.id == ME_RLeft)
     {
-        if (itemTypes.getEintragAnzahl() > currentIconIndex)
+        if (itemTypes.getEntryCount() > currentIconIndex)
         {
             World::INSTANCE->zClient()->craftingUIMLRequest(
                 itemTypes.get(currentIconIndex));
         }
     }
-    ZeichnungHintergrund::doMausEreignis(me, userRet);
+    DrawableBackground::doMouseEvent(me, userRet);
 }
 
 Requirement::Requirement(
@@ -393,9 +391,9 @@ Requirement* Requirement::clone()
 
 bool Requirement::contradicts(Requirement* zOther)
 {
-    if (zOther->attribute.istGleich(attribute.getText()))
+    if (zOther->attribute.isEqual(attribute.getText()))
     {
-        if (zOther->value.istGleich(value))
+        if (zOther->value.isEqual(value))
         {
             if (op == AttributeOperator::Equals
                 && zOther->op == AttributeOperator::NotEquals)
@@ -492,9 +490,9 @@ bool Requirement::contradicts(Requirement* zOther)
 
 bool Requirement::merge(Requirement* zOther)
 {
-    if (zOther->attribute.istGleich(attribute.getText()))
+    if (zOther->attribute.isEqual(attribute.getText()))
     {
-        if (zOther->value.istGleich(value))
+        if (zOther->value.isEqual(value))
         {
             if (op == zOther->op)
             {
@@ -658,7 +656,7 @@ bool Requirement::merge(Requirement* zOther)
 
 int Requirement::getItemType()
 {
-    if (attribute.istGleich("Type") && op == AttributeOperator::Equals)
+    if (attribute.isEqual("Type") && op == AttributeOperator::Equals)
     {
         return (int)value;
     }
@@ -759,7 +757,7 @@ bool RequirementSet::isNoneMatch() const
 
 bool RequirementSet::isAnyMatch() const
 {
-    return requirements.getEintragAnzahl() == 0;
+    return requirements.getEntryCount() == 0;
 }
 
 Framework::Text RequirementSet::renderToTooltip() const
@@ -793,7 +791,7 @@ Framework::Text RequirementSet::renderToTooltip() const
     {
         result += zItemType(itemType)->getName();
     }
-    if (requirements.getEintragAnzahl() > 0)
+    if (requirements.getEntryCount() > 0)
     {
         bool first = 1;
         for (Requirement* req : requirements)
@@ -814,7 +812,7 @@ Framework::Text RequirementSet::renderToTooltip() const
     return result;
 }
 
-Framework::Bild* RequirementSet::getIcon() const
+Framework::Image* RequirementSet::getIcon() const
 {
     int itemType = -1;
     for (Requirement* req : requirements)
@@ -834,21 +832,21 @@ Framework::Bild* RequirementSet::getIcon() const
     }
     if (itemType == -2)
     {
-        LTDBDatei dat;
-        dat.setDatei(new Text("data/images/gui_icons.ltdb"));
-        dat.leseDaten(0);
-        return dat.laden(0, new Text("noitem.png"));
+        LTDBFile dat;
+        dat.setFile(new Text("data/images/gui_icons.ltdb"));
+        dat.readData(0);
+        return dat.load(0, new Text("noitem.png"));
     }
     else if (itemType == -1)
     {
-        LTDBDatei dat;
-        dat.setDatei(new Text("data/images/gui_icons.ltdb"));
-        dat.leseDaten(0);
-        return dat.laden(0, new Text("anyitem.png"));
+        LTDBFile dat;
+        dat.setFile(new Text("data/images/gui_icons.ltdb"));
+        dat.readData(0);
+        return dat.load(0, new Text("anyitem.png"));
     }
     else
     {
-        return dynamic_cast<Framework::Bild*>(
+        return dynamic_cast<Framework::Image*>(
             zItemType(itemType)->zIcon()->getThis());
     }
 }
@@ -901,7 +899,7 @@ Framework::RCArray<RequirementSet>* LogicTree::multiply(
             {
                 if (set->isAnyMatch())
                 {
-                    result->leeren();
+                    result->clear();
                     result->add(set);
                     a->release();
                     b->release();
@@ -989,7 +987,7 @@ Framework::RCArray<RequirementSet>* LogicTree::resolve()
         else if (op == LogicalOperator::AND)
         {
             result = children.z(0)->resolve();
-            for (int i = 1; i < children.getEintragAnzahl(); i++)
+            for (int i = 1; i < children.getEntryCount(); i++)
             {
                 Framework::RCArray<RequirementSet>* childSet
                     = children.z(i)->resolve();
@@ -998,7 +996,7 @@ Framework::RCArray<RequirementSet>* LogicTree::resolve()
         }
         if (result != 0)
         {
-            for (int i = 0; i < result->getEintragAnzahl(); i++)
+            for (int i = 0; i < result->getEntryCount(); i++)
             {
                 if (result->z(i)->isNoneMatch())
                 {

FactoryCraft/RecipieIngredient.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <TextFeld.h>
+#include <TextField.h>
 #include <UIMLView.h>
 
 class LogicTree;
@@ -15,27 +15,27 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class RecipieIngredient : public Framework::ZeichnungHintergrund
+class RecipieIngredient : public Framework::DrawableBackground
 {
 private:
-    Framework::RCArray<Framework::Bild> icons;
+    Framework::RCArray<Framework::Image> icons;
     Framework::RCArray<Framework::Text> toolTips;
     Framework::Array<int> itemTypes;
-    Framework::TextFeld* toolTip;
+    Framework::TextField* toolTip;
     int currentIconIndex;
     double timtUntilNextIcon;
     int amount;
@@ -44,11 +44,11 @@ public:
     RecipieIngredient(int amount);
 
     void addPossibleItem(
-        Framework::Bild* icon, Framework::Text* toolTip, int itemType);
+        Framework::Image* icon, Framework::Text* toolTip, int itemType);
 
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };
 
 enum class AttributeOperator
@@ -97,7 +97,7 @@ public:
     bool isNoneMatch() const;
     bool isAnyMatch() const;
     Framework::Text renderToTooltip() const;
-    Framework::Bild* getIcon() const;
+    Framework::Image* getIcon() const;
     int getItemType() const;
 };
 

FactoryCraft/RecipieOutput.cpp

@@ -13,11 +13,11 @@ RecipieOutputElement::RecipieOutputElement()
 //! ist
 bool RecipieOutputElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("output");
+    return element.getName().isEqual("output");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* RecipieOutputElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* RecipieOutputElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     SlotInfo info;
@@ -33,15 +33,15 @@ Framework::Zeichnung* RecipieOutputElement::parseElement(
 }
 
 bool RecipieOutputElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void RecipieOutputElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -54,17 +54,17 @@ void RecipieOutputElement::layout(Framework::XML::Element& element,
 RecipieOutput::RecipieOutput(SlotInfo info, Framework::Text toolTipUIML)
     : info(info)
 {
-    setStyle(Framework::Zeichnung::Style::Erlaubt
-             | Framework::Zeichnung::Style::Sichtbar);
+    setStyle(Framework::Drawable::Style::Allowed
+             | Framework::Drawable::Style::Visible);
     UIMLToolTip* tip = new UIMLToolTip();
     tip->setUIML(toolTipUIML);
     tip->setWarten(0.5);
     setToolTipZ(tip);
 }
 
-void RecipieOutput::render(Framework::Bild& rObj)
+void RecipieOutput::render(Framework::Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     info.render(-1, -1, rObj, 0, 0);
     rObj.releaseDrawOptions();

FactoryCraft/RecipieOutput.h

@@ -11,26 +11,26 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class RecipieOutput : public Framework::ZeichnungHintergrund
+class RecipieOutput : public Framework::DrawableBackground
 {
 private:
     SlotInfo info;
 
 public:
     RecipieOutput(SlotInfo info, Framework::Text toolTipUIML);
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };

FactoryCraft/ServerSelection.cpp

@@ -1,19 +1,19 @@
 #include "ServerSelection.h"
 
-#include <AlphaFeld.h>
+#include <AlphaField.h>
 #include <AsynchronCall.h>
 #include <Base64.h>
-#include <Bild.h>
+#include <Button.h>
 #include <DataValidator.h>
-#include <Datei.h>
-#include <DateiSystem.h>
+#include <File.h>
+#include <FileSystem.h>
+#include <Font.h>
+#include <Image.h>
 #include <JSON.h>
-#include <Knopf.h>
-#include <Schrift.h>
 
 #include "FactoryClient.h"
 #include "Globals.h"
-#include "Initialisierung.h"
+#include "Initialization.h"
 #include "Load.h"
 
 using namespace Framework;
@@ -23,7 +23,7 @@ ServerStatus::ServerStatus(Framework::Text name,
     unsigned short sslPort,
     unsigned short port,
     Framework::HashMap<Framework::Text, Framework::Text>* secrets)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       name(name),
       ip(ip),
       sslPort(sslPort),
@@ -34,24 +34,24 @@ ServerStatus::ServerStatus(Framework::Text name,
       statusId(0),
       requestId(0),
       secrets(secrets),
-      join(initKnopf(0, 0, 55, 20, Knopf::Style::Normal, "join"))
+      join(initButton(0, 0, 55, 20, Button::Style::Normal, "join"))
 {
-    setMausEreignis(_ret1ME);
-    setStyle(Style::Erlaubt | Style::Sichtbar | Style::Rahmen);
-    setRahmenBreite(1);
-    setRahmenFarbe(0xFF3d3d3d);
-    join->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+    setMouseEvent(_ret1ME);
+    setStyle(Style::Allowed | Style::Visible | Style::Border);
+    setBorderWidth(1);
+    setBorderColor(0xFF3d3d3d);
+    join->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             FactoryClient* client = new FactoryClient();
             if (!client->connect(getIp(), getSSLPort()))
             {
-                lockZeichnung();
+                lockDrawable();
                 status = "The Server is currently not reachable";
                 statusId = 404;
                 ping = -1;
                 rend = 1;
-                unlockZeichnung();
+                unlockDrawable();
                 client->release();
             }
             else
@@ -70,14 +70,14 @@ ServerStatus::ServerStatus(Framework::Text name,
                         getPort(),
                         [this, isNew, client](int result, Text secret) {
                             menuRegister->get("load")->hide();
-                            lockZeichnung();
+                            lockDrawable();
                             statusId = result;
                             if (statusId == 403)
                                 status = "The name is already in use";
                             if (statusId == 500)
                                 status = "Unknown Server message received";
                             if (statusId == 201) status = "Please try again";
-                            unlockZeichnung();
+                            unlockDrawable();
                             if (statusId == 200 || statusId == 201)
                             {
                                 if (isNew)
@@ -90,8 +90,8 @@ ServerStatus::ServerStatus(Framework::Text name,
                                 if (statusId == 200)
                                 {
                                     World::INSTANCE
-                                        = new World(dynamic_cast<Bildschirm3D*>(
-                                                        window->zBildschirm()),
+                                        = new World(dynamic_cast<Screen3D*>(
+                                                        window->zScreen()),
                                             client);
                                     menuRegister->get("game")->show();
                                 }
@@ -113,26 +113,26 @@ ServerStatus::ServerStatus(Framework::Text name,
         return 1;
     });
 
-    LTDBDatei iconsDat;
-    iconsDat.setDatei(new Text("data/images/gui_icons.ltdb"));
-    iconsDat.leseDaten(0);
+    LTDBFile iconsDat;
+    iconsDat.setFile(new Text("data/images/gui_icons.ltdb"));
+    iconsDat.readData(0);
 
-    removeButton = initKnopf(0,
+    removeButton = initButton(0,
         0,
         20,
         20,
-        Framework::Knopf::Style::HBild | Framework::Knopf::Style::HAlpha
-            | Framework::Knopf::Style::Hintergrund,
+        Framework::Button::Style::BImage | Framework::Button::Style::BAlpha
+            | Framework::Button::Style::Background,
         "");
-    removeButton->setRahmenFarbe(0xFF9C0A0A);
-    removeButton->setAlphaFeldFarbe(0x5F9C0A0A);
+    removeButton->setBorderColor(0xFF9C0A0A);
+    removeButton->setAlphaFieldColor(0x5F9C0A0A);
     removeButton->setToolTipText("Remove player from list of ignored players",
         uiFactory.initParam.bildschirm,
-        uiFactory.initParam.schrift);
-    removeButton->setHintergrundBildZ(
-        dynamic_cast<Bild*>(iconsDat.laden(0, new Text("trash.png"))));
-    removeButton->setMausEreignis([this](void* p, void* o, MausEreignis me) {
-        if (me.id == ME_RLinks)
+        uiFactory.initParam.font);
+    removeButton->setBackgroundImageZ(
+        dynamic_cast<Image*>(iconsDat.load(0, new Text("trash.png"))));
+    removeButton->setMouseEvent([this](void* p, void* o, MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             ((ServerSelectionMenu*)(Menu*)menuRegister->get("serverSelection"))
                 ->removeServer(this->name);
@@ -150,17 +150,17 @@ ServerStatus::~ServerStatus()
 
 void ServerStatus::updatePlayerName(Framework::Text playerName)
 {
-    lockZeichnung();
+    lockDrawable();
     status = "";
     this->playerName = playerName;
     ServerStatus* tmp = dynamic_cast<ServerStatus*>(getThis());
     int id = ++requestId;
-    unlockZeichnung();
+    unlockDrawable();
     new AsynchronCall([tmp, id]() {
         FactoryClient* client = new FactoryClient();
         if (!client->connect(tmp->getIp(), tmp->getSSLPort()))
         {
-            tmp->lockZeichnung();
+            tmp->lockDrawable();
             if (tmp->requestId == id)
             {
                 tmp->status = "The Server is currently not reachable";
@@ -168,17 +168,17 @@ void ServerStatus::updatePlayerName(Framework::Text playerName)
                 tmp->ping = -1;
                 tmp->rend = 1;
             }
-            tmp->unlockZeichnung();
+            tmp->unlockDrawable();
         }
         else
         {
-            tmp->lockZeichnung();
+            tmp->lockDrawable();
             if (tmp->requestId == id)
             {
                 Text secret = "";
                 if (tmp->secrets->has(tmp->playerName))
                     secret = tmp->secrets->get(tmp->playerName);
-                tmp->unlockZeichnung();
+                tmp->unlockDrawable();
                 int ping = client->ping();
                 int statusId = client->status(tmp->playerName, secret);
                 if (statusId == 403)
@@ -186,11 +186,11 @@ void ServerStatus::updatePlayerName(Framework::Text playerName)
                     int secondStatus = client->status(tmp->playerName, "");
                     if (secondStatus == 200) statusId = 203;
                 }
-                if (secret.istGleich("") && statusId == 200)
+                if (secret.isEqual("") && statusId == 200)
                 {
                     statusId = 203;
                 }
-                tmp->lockZeichnung();
+                tmp->lockDrawable();
                 if (tmp->requestId == id)
                 {
                     tmp->ping = ping;
@@ -203,44 +203,44 @@ void ServerStatus::updatePlayerName(Framework::Text playerName)
                     tmp->rend = 1;
                 }
             }
-            tmp->unlockZeichnung();
+            tmp->unlockDrawable();
         }
         client->release();
         tmp->release();
     });
 }
 
-void ServerStatus::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void ServerStatus::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    removeButton->doPublicMausEreignis(me);
-    if (canConnect()) join->doPublicMausEreignis(me);
+    removeButton->doPublicMouseEvent(me);
+    if (canConnect()) join->doPublicMouseEvent(me);
 }
 
 bool ServerStatus::tick(double time)
 {
     join->setPosition(gr.x - 60, gr.y - 25);
     removeButton->setPosition(gr.x - 20, 0);
-    return ZeichnungHintergrund::tick(time) || join->tick(time)
+    return DrawableBackground::tick(time) || join->tick(time)
         || removeButton->tick(time);
 }
 
-void ServerStatus::render(Framework::Bild& rObj)
+void ServerStatus::render(Framework::Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
+    DrawableBackground::render(rObj);
     if (rObj.setDrawOptions(pos, gr))
     {
         TextRenderer tr(
-            dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-        tr.setSchriftSize(12);
+            dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+        tr.setFontSize(12);
         tr.renderText(5, 5, name, rObj, 0xFFFFFFFF);
         tr.renderText(
             5, 25, ip + ":" + sslPort + " (" + port + ")", rObj, 0xFF808080);
         if (requestId && requestId != 404)
         {
-            int tbr = tr.getTextBreite(Text("ping: ") + ping);
+            int tbr = tr.getTextWidth(Text("ping: ") + ping);
             if (ping >= 0)
             {
-                tr.renderText(getBreite() - 25 - tbr,
+                tr.renderText(getWidth() - 25 - tbr,
                     5,
                     Text("ping: ") + ping,
                     rObj,
@@ -289,101 +289,101 @@ bool ServerStatus::canConnect() const
     return statusId == 200 || statusId == 201 || statusId == 203;
 }
 
-ServerSelectionMenu::ServerSelectionMenu(Bildschirm* zScreen)
+ServerSelectionMenu::ServerSelectionMenu(Screen* zScreen)
     : Menu(zScreen)
 {
-    playerNameLabel = initTextFeld(zScreen->getBackBufferSize().x / 2 - 150,
+    playerNameLabel = initTextField(zScreen->getBackBufferSize().x / 2 - 150,
         zScreen->getBackBufferSize().y / 2 - 300,
         85,
         20,
-        TextFeld::Style::Text | TextFeld::Style::VCenter,
+        TextField::Style::Text | TextField::Style::VCenter,
         "Player Name:");
     elements.add(playerNameLabel);
-    playerName = initTextFeld(zScreen->getBackBufferSize().x / 2 - 150 + 85,
+    playerName = initTextField(zScreen->getBackBufferSize().x / 2 - 150 + 85,
         zScreen->getBackBufferSize().y / 2 - 300,
         215,
         20,
-        TextFeld::Style::TextFeld,
+        TextField::Style::TextField,
         "");
-    playerName->setNTastaturEreignis(
-        [this](void* p, void* o, TastaturEreignis te) {
+    playerName->setPostKeyboardEvent(
+        [this](void* p, void* o, KeyboardEvent te) {
             // set player names of each server
-            for (int i = 0; i < serverList->getEintragAnzahl(); i++)
-                ((ServerStatus*)serverList->zEintrag(i))
+            for (int i = 0; i < serverList->getEntryCount(); i++)
+                ((ServerStatus*)serverList->zEntry(i))
                     ->updatePlayerName(playerName->zText()->getText());
             saveServers();
             return 1;
         });
     elements.add(playerName);
-    serverLabel = initTextFeld(zScreen->getBackBufferSize().x / 2 - 150,
+    serverLabel = initTextField(zScreen->getBackBufferSize().x / 2 - 150,
         zScreen->getBackBufferSize().y / 2 - 275,
         100,
         20,
-        TextFeld::Style::Text | TextFeld::Style::VCenter,
+        TextField::Style::Text | TextField::Style::VCenter,
         "Server:");
     elements.add(serverLabel);
-    refresh = initKnopf(zScreen->getBackBufferSize().x / 2 + 80,
+    refresh = initButton(zScreen->getBackBufferSize().x / 2 + 80,
         zScreen->getBackBufferSize().y / 2 - 275,
         70,
         20,
-        Knopf::Style::Normal,
+        Button::Style::Normal,
         "Refresh");
-    refresh->setMausEreignis(
-        [this](void* p, void* o, Framework::MausEreignis me) {
-            if (me.id == ME_RLinks)
+    refresh->setMouseEvent([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == ME_RLeft)
+        {
+            if (playerName->zText()->getLength() > 0)
             {
-                if (playerName->zText()->getLength() > 0)
-                {
-                    for (int i = 0; i < serverList->getEintragAnzahl(); i++)
-                        ((ServerStatus*)serverList->zEintrag(i))
-                            ->updatePlayerName(playerName->zText()->getText());
-                }
+                for (int i = 0; i < serverList->getEntryCount(); i++)
+                    ((ServerStatus*)serverList->zEntry(i))
+                        ->updatePlayerName(playerName->zText()->getText());
             }
-            return 1;
-        });
+        }
+        return 1;
+    });
     elements.add(refresh);
-    serverList = new ZListe();
+    serverList = new DrawableList();
     serverList->setSize(300, 480);
-    serverList->setRahmenBreite(1);
-    serverList->setRahmenFarbe(0xFF6d6d6d);
+    serverList->setBorderWidth(1);
+    serverList->setBorderColor(0xFF6d6d6d);
     serverList->setPosition(zScreen->getBackBufferSize().x / 2 - 150,
         zScreen->getBackBufferSize().y / 2 - 250);
-    serverList->setStyle(ZListe::Style::Normal | ZListe::Style::VScroll);
-    serverList->setMausEreignis(_ret1ME);
-    serverList->setVertikalScrollPos(0);
+    serverList->setStyle(
+        DrawableList::Style::Normal | DrawableList::Style::VScroll);
+    serverList->setMouseEvent(_ret1ME);
+    serverList->setVerticalScrollPos(0);
     serverList->setEntrySeperatorSize(1);
     serverList->setEntrySeperatorColor(0xFF6d6d6d);
     elements.add(serverList);
-    add = initKnopf(zScreen->getBackBufferSize().x / 2 - 50,
+    add = initButton(zScreen->getBackBufferSize().x / 2 - 50,
         zScreen->getBackBufferSize().y / 2 + 235,
         100,
         20,
-        Knopf::Style::Normal,
+        Button::Style::Normal,
         "Add Server");
     elements.add(add);
-    add->setMausEreignis([this](void* p, void* o, Framework::MausEreignis me) {
-        if (me.id == ME_RLinks)
+    add->setMouseEvent([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             hide();
             menuRegister->get("addServer")->show();
         }
         return 1;
     });
-    exit = initKnopf(zScreen->getBackBufferSize().x / 2 - 50,
+    exit = initButton(zScreen->getBackBufferSize().x / 2 - 50,
         zScreen->getBackBufferSize().y / 2 + 285,
         100,
         20,
-        Knopf::Style::Normal,
+        Button::Style::Normal,
         "Beenden");
     elements.add(exit);
-    exit->setRahmenFarbe(0xFF9C0A0A);
-    exit->setAlphaFeldStrength(10);
-    exit->setAlphaFeldFarbe(0x5F9C0A0A);
-    exit->setMausEreignis([this](void* p, void* o, Framework::MausEreignis me) {
-        if (me.id == ME_RLinks)
+    exit->setBorderColor(0xFF9C0A0A);
+    exit->setAlphaFieldStrength(10);
+    exit->setAlphaFieldColor(0x5F9C0A0A);
+    exit->setMouseEvent([this](void* p, void* o, Framework::MouseEvent me) {
+        if (me.id == ME_RLeft)
         {
             hide();
-            StopNachrichtenSchleife(0);
+            StopMessageLoop(0);
         }
         return 1;
     });
@@ -469,7 +469,7 @@ ServerSelectionMenu::ServerSelectionMenu(Bildschirm* zScreen)
                         ->getNumber(),
                     secrets);
                 s->setSize(300, 65);
-                serverList->addEintrag(s);
+                serverList->addEntry(s);
             }
             playerName->setText(validJson->asObject()
                     ->zValue("playerName")
@@ -477,8 +477,8 @@ ServerSelectionMenu::ServerSelectionMenu(Bildschirm* zScreen)
                     ->getString());
             if (playerName->zText()->getLength() > 0)
             {
-                for (int i = 0; i < serverList->getEintragAnzahl(); i++)
-                    ((ServerStatus*)serverList->zEintrag(i))
+                for (int i = 0; i < serverList->getEntryCount(); i++)
+                    ((ServerStatus*)serverList->zEntry(i))
                         ->updatePlayerName(playerName->zText()->getText());
             }
             serverList->updateVScroll();
@@ -500,7 +500,7 @@ void ServerSelectionMenu::addServer(Framework::Text name,
         new HashMap<Framework::Text, Framework::Text>(
             10, [](Text t) { return t.hashCode(); }));
     tmp->setSize(300, 65);
-    serverList->addEintrag(tmp);
+    serverList->addEntry(tmp);
     tmp->updatePlayerName(playerName->zText()->getText());
     serverList->updateVScroll();
     saveServers();
@@ -508,20 +508,19 @@ void ServerSelectionMenu::addServer(Framework::Text name,
 
 bool ServerSelectionMenu::hasServer(Framework::Text name) const
 {
-    for (int i = 0; i < serverList->getEintragAnzahl(); i++)
+    for (int i = 0; i < serverList->getEntryCount(); i++)
     {
-        if (((ServerStatus*)serverList->zEintrag(i))->getName() == name)
-            return 1;
+        if (((ServerStatus*)serverList->zEntry(i))->getName() == name) return 1;
     }
     return 0;
 }
 
 void ServerSelectionMenu::removeServer(Framework::Text name) const
 {
-    for (int i = 0; i < serverList->getEintragAnzahl(); i++)
+    for (int i = 0; i < serverList->getEntryCount(); i++)
     {
-        if (((ServerStatus*)serverList->zEintrag(i))->getName() == name)
-            serverList->removeEintrag(i);
+        if (((ServerStatus*)serverList->zEntry(i))->getName() == name)
+            serverList->removeEntry(i);
     }
     serverList->updateVScroll();
     saveServers();
@@ -529,29 +528,29 @@ void ServerSelectionMenu::removeServer(Framework::Text name) const
 
 void ServerSelectionMenu::saveServers() const
 {
-    Datei file;
-    file.setDatei("data/server.json");
-    file.open(Datei::Style::schreiben);
+    File file;
+    file.setFile("data/server.json");
+    file.open(File::Style::write);
     JSON::JSONObject root;
     JSON::JSONArray* servers = new JSON::JSONArray();
-    for (int i = 0; i < serverList->getEintragAnzahl(); i++)
+    for (int i = 0; i < serverList->getEntryCount(); i++)
     {
         JSON::JSONObject* server = new JSON::JSONObject();
         server->addValue("name",
             new JSON::JSONString(
-                ((ServerStatus*)serverList->zEintrag(i))->getName()));
+                ((ServerStatus*)serverList->zEntry(i))->getName()));
         server->addValue("ip",
             new JSON::JSONString(
-                ((ServerStatus*)serverList->zEintrag(i))->getIp()));
+                ((ServerStatus*)serverList->zEntry(i))->getIp()));
         server->addValue("sslPort",
             new JSON::JSONNumber(
-                ((ServerStatus*)serverList->zEintrag(i))->getSSLPort()));
+                ((ServerStatus*)serverList->zEntry(i))->getSSLPort()));
         server->addValue("port",
             new JSON::JSONNumber(
-                ((ServerStatus*)serverList->zEintrag(i))->getPort()));
+                ((ServerStatus*)serverList->zEntry(i))->getPort()));
         JSON::JSONArray* secrets = new JSON::JSONArray();
         for (auto secretEntry :
-            *((ServerStatus*)serverList->zEintrag(i))->zSecrets())
+            *((ServerStatus*)serverList->zEntry(i))->zSecrets())
         {
             JSON::JSONObject* secret = new JSON::JSONObject();
             secret->addValue(
@@ -569,6 +568,6 @@ void ServerSelectionMenu::saveServers() const
     root.addValue(
         "playerName", new JSON::JSONString(playerName->zText()->getText()));
     Framework::Text json = root.toString();
-    file.schreibe(json, json.getLength());
+    file.write(json, json.getLength());
     file.close();
 }

FactoryCraft/ServerSelection.h

@@ -1,13 +1,13 @@
 #pragma once
 
 #include <HashMap.h>
-#include <Knopf.h>
-#include <Liste.h>
-#include <TextFeld.h>
+#include <Button.h>
+#include <List.h>
+#include <TextField.h>
 
 #include "Menu.h"
 
-class ServerStatus : public ZeichnungHintergrund
+class ServerStatus : public DrawableBackground
 {
 private:
     Framework::Text name;
@@ -20,8 +20,8 @@ private:
     int statusId;
     int requestId;
     Framework::HashMap<Framework::Text, Framework::Text>* secrets;
-    Framework::Knopf* removeButton;
-    Framework::Knopf* join;
+    Framework::Button* removeButton;
+    Framework::Button* join;
 
 public:
     ServerStatus(Framework::Text name,
@@ -33,10 +33,10 @@ public:
 
     virtual void updatePlayerName(Framework::Text playerName);
 
-    virtual void doMausEreignis(
-        Framework::MausEreignis& me, bool userRet) override;
+    virtual void doMouseEvent(
+        Framework::MouseEvent& me, bool userRet) override;
     virtual bool tick(double time) override;
-    virtual void render(Framework::Bild& rObj) override;
+    virtual void render(Framework::Image& rObj) override;
 
     Framework::Text getName() const;
     Framework::Text getIp() const;
@@ -49,16 +49,16 @@ public:
 class ServerSelectionMenu : public Menu
 {
 private:
-    Framework::TextFeld* playerName;
-    Framework::TextFeld* playerNameLabel;
-    Framework::TextFeld* serverLabel;
-    Framework::ZListe* serverList;
-    Framework::Knopf* add;
-    Framework::Knopf* refresh;
-    Framework::Knopf* exit;
+    Framework::TextField* playerName;
+    Framework::TextField* playerNameLabel;
+    Framework::TextField* serverLabel;
+    Framework::DrawableList* serverList;
+    Framework::Button* add;
+    Framework::Button* refresh;
+    Framework::Button* exit;
 
 public:
-    ServerSelectionMenu(Framework::Bildschirm* zScreen);
+    ServerSelectionMenu(Framework::Screen* zScreen);
     void addServer(Framework::Text name,
         Framework::Text ip,
         unsigned short sslPort,

FactoryCraft/ShapedRecipie.cpp

@@ -1,6 +1,6 @@
 #include "ShapedRecipie.h"
 
-#include <Bild.h>
+#include <Image.h>
 #include <XML.h>
 
 ShapedRecipieElement::ShapedRecipieElement()
@@ -11,12 +11,12 @@ ShapedRecipieElement::ShapedRecipieElement()
 //! ist
 bool ShapedRecipieElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("recipie")
-        && element.getAttributeValue("type").istGleich("shaped");
+    return element.getName().isEqual("recipie")
+        && element.getAttributeValue("type").isEqual("shaped");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* ShapedRecipieElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* ShapedRecipieElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     int width = (int)element.getAttributeValue("width");
@@ -40,15 +40,15 @@ Framework::Zeichnung* ShapedRecipieElement::parseElement(
 }
 
 bool ShapedRecipieElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void ShapedRecipieElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -71,17 +71,17 @@ void ShapedRecipieElement::layout(Framework::XML::Element& element,
     z.setHeight(height * 60 - 10);
     element.selectChildren().selectChildren().forEach(
         [&z, &generalLayouter](Framework::XML::Element* zElement) {
-            Framework::Zeichnung* child = 0;
+            Framework::Drawable* child = 0;
             if (zElement->hasAttribute("id"))
             {
-                child = generalLayouter.zZeichnungById(
+                child = generalLayouter.zDrawableById(
                     zElement->getAttributeValue("id"));
             }
             if (child)
             {
                 generalLayouter.layout(*zElement,
                     *child,
-                    z.getBreite(),
+                    z.getWidth(),
                     z.getHeight(),
                     generalLayouter);
             }
@@ -89,20 +89,20 @@ void ShapedRecipieElement::layout(Framework::XML::Element& element,
 }
 
 ShapedRecipie::ShapedRecipie(int width, int height)
-    : Framework::ZeichnungHintergrund(),
+    : Framework::DrawableBackground(),
       width(width),
       height(height)
 {
-    setStyle(Framework::Zeichnung::Style::Erlaubt
-             | Framework::Zeichnung::Style::Sichtbar);
+    setStyle(Framework::Drawable::Style::Allowed
+             | Framework::Drawable::Style::Visible);
 }
 
-void ShapedRecipie::addIngredient(Zeichnung* ingredient)
+void ShapedRecipie::addIngredient(Drawable* ingredient)
 {
     ingredients.add(ingredient);
 }
 
-void ShapedRecipie::addOutput(Zeichnung* output)
+void ShapedRecipie::addOutput(Drawable* output)
 {
     outputs.add(output);
 }
@@ -110,25 +110,25 @@ void ShapedRecipie::addOutput(Zeichnung* output)
 bool ShapedRecipie::tick(double tickVal)
 {
     bool ret = false;
-    for (Zeichnung* ingredient : ingredients)
+    for (Drawable* ingredient : ingredients)
     {
         ret |= ingredient->tick(tickVal);
     }
-    for (Zeichnung* output : outputs)
+    for (Drawable* output : outputs)
     {
         ret |= output->tick(tickVal);
     }
     return ret;
 }
 
-void ShapedRecipie::render(Framework::Bild& rObj)
+void ShapedRecipie::render(Framework::Image& rObj)
 {
-    if (!hatStyle(Zeichnung::Style::Sichtbar)) return;
-    ZeichnungHintergrund::render(rObj);
+    if (!hasStyle(Drawable::Style::Visible)) return;
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     int x = 0;
     int y = 0;
-    for (Zeichnung* ingredient : ingredients)
+    for (Drawable* ingredient : ingredients)
     {
         ingredient->setX(x);
         ingredient->setY(y);
@@ -141,13 +141,13 @@ void ShapedRecipie::render(Framework::Bild& rObj)
         }
     }
     rObj.fillRegion(width * 60, gr.y / 2 - 5, 25, 10, 0xFF52525E);
-    rObj.drawDreieck(Framework::Punkt(width * 60 + 25, gr.y / 2 - 15),
-        Framework::Punkt(width * 60 + 40, gr.y / 2),
-        Framework::Punkt(width * 60 + 25, gr.y / 2 + 15),
+    rObj.drawTriangle(Framework::Point(width * 60 + 25, gr.y / 2 - 15),
+        Framework::Point(width * 60 + 40, gr.y / 2),
+        Framework::Point(width * 60 + 25, gr.y / 2 + 15),
         0xFF52525E);
     x = width * 60 + 50;
     y = 0;
-    for (Zeichnung* output : outputs)
+    for (Drawable* output : outputs)
     {
         output->setX(x);
         output->setY(y);
@@ -157,14 +157,14 @@ void ShapedRecipie::render(Framework::Bild& rObj)
     rObj.releaseDrawOptions();
 }
 
-void ShapedRecipie::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void ShapedRecipie::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    for (Zeichnung* ingredient : ingredients)
+    for (Drawable* ingredient : ingredients)
     {
-        ingredient->doPublicMausEreignis(me);
+        ingredient->doPublicMouseEvent(me);
     }
-    for (Zeichnung* output : outputs)
+    for (Drawable* output : outputs)
     {
-        output->doPublicMausEreignis(me);
+        output->doPublicMouseEvent(me);
     }
 }

FactoryCraft/ShapedRecipie.h

@@ -9,33 +9,33 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class ShapedRecipie : public Framework::ZeichnungHintergrund
+class ShapedRecipie : public Framework::DrawableBackground
 {
 private:
-    Framework::RCArray<Zeichnung> ingredients;
-    Framework::RCArray<Zeichnung> outputs;
+    Framework::RCArray<Drawable> ingredients;
+    Framework::RCArray<Drawable> outputs;
     int width;
     int height;
 
 public:
     ShapedRecipie(int width, int height);
-    void addIngredient(Zeichnung* ingredient);
-    void addOutput(Zeichnung* output);
+    void addIngredient(Drawable* ingredient);
+    void addOutput(Drawable* output);
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };

FactoryCraft/StatusBars.cpp

@@ -1,7 +1,7 @@
 #include "StatusBars.h"
 
-#include <Bild.h>
-#include <DateiSystem.h>
+#include <FileSystem.h>
+#include <Image.h>
 #include <XML.h>
 
 #include "Globals.h"
@@ -10,15 +10,15 @@ StatusBarsElement::StatusBarsElement()
     : UIMLElement()
 {}
 
-//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
+//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
 //! ist
 bool StatusBarsElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("statusBars");
+    return element.getName().isEqual("statusBars");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* StatusBarsElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* StatusBarsElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     return new StatusBarsView(element.getAttributeValue("id"),
@@ -26,15 +26,15 @@ Framework::Zeichnung* StatusBarsElement::parseElement(
 }
 
 bool StatusBarsElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void StatusBarsElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -45,32 +45,31 @@ void StatusBarsElement::layout(Framework::XML::Element& element,
 }
 
 StatusBarsView::StatusBarsView(Framework::Text id, int targetEntity)
-    : ZeichnungHintergrund(),
+    : DrawableBackground(),
       NetworkAPIProcessor(),
       id(id),
       targetEntity(targetEntity)
 {
-    setStyle(ZeichnungHintergrund::Style::Sichtbar
-             | ZeichnungHintergrund::Style::Rahmen
-             | ZeichnungHintergrund::Style::Hintergrund
-             | ZeichnungHintergrund::Style::HAlpha);
-    setRahmenFarbe(0xA052525E);
-    setHintergrundFarbe(0xA0222222);
-    setRahmenBreite(2);
-    Framework::LTDBDatei file;
-    file.setDatei(new Framework::Text("data/images/gui_icons.ltdb"));
-    file.leseDaten(0);
-    healthIcon = file.laden(0, new Framework::Text("health.png"));
-    energyIcon = file.laden(0, new Framework::Text("energy.png"));
-    hungerIcon = file.laden(0, new Framework::Text("food.png"));
-    thirstIcon = file.laden(0, new Framework::Text("water.png"));
+    setStyle(DrawableBackground::Style::Visible
+             | DrawableBackground::Style::Border
+             | DrawableBackground::Style::Background
+             | DrawableBackground::Style::BAlpha);
+    setBorderColor(0xA052525E);
+    setBackgroundColor(0xA0222222);
+    setBorderWidth(2);
+    Framework::LTDBFile file;
+    file.setFile(new Framework::Text("data/images/gui_icons.ltdb"));
+    file.readData(0);
+    healthIcon = file.load(0, new Framework::Text("health.png"));
+    energyIcon = file.load(0, new Framework::Text("energy.png"));
+    hungerIcon = file.load(0, new Framework::Text("food.png"));
+    thirstIcon = file.load(0, new Framework::Text("water.png"));
     health = 0.f;
     hunger = 0.f;
     thirst = 0.f;
     energy = 0.f;
-    tr.setSchriftZ(
-        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
-    tr.setSchriftSize(12);
+    tr.setFontZ(dynamic_cast<Font*>(uiFactory.initParam.font->getThis()));
+    tr.setFontSize(12);
     char* msg = new char[id.getLength() + 6];
     msg[0] = 0; // request status bar state
     msg[1] = (char)id.getLength();
@@ -115,12 +114,12 @@ void StatusBarsView::api(char* message)
             this->energy = stamina / maxStamina;
             this->hunger = hunger / maxHunger;
             this->thirst = thirst / maxThirst;
-            lockZeichnung();
+            lockDrawable();
             healthText = (int)ceil(health);
             energyText = (int)ceil(stamina);
             hungerText = (int)ceil(hunger);
             thirstText = (int)ceil(thirst);
-            unlockZeichnung();
+            unlockDrawable();
             break;
         }
     case 1: // update health
@@ -128,9 +127,9 @@ void StatusBarsView::api(char* message)
             float maxHealth = *(float*)(message + 1);
             float health = *(float*)(message + 5);
             this->health = health / maxHealth;
-            lockZeichnung();
+            lockDrawable();
             healthText = (int)ceil(health);
-            unlockZeichnung();
+            unlockDrawable();
             break;
         }
     case 2: // update stamina
@@ -138,9 +137,9 @@ void StatusBarsView::api(char* message)
             float maxStamina = *(float*)(message + 1);
             float stamina = *(float*)(message + 5);
             this->energy = stamina / maxStamina;
-            lockZeichnung();
+            lockDrawable();
             energyText = (int)ceil(stamina);
-            unlockZeichnung();
+            unlockDrawable();
             break;
         }
     case 3: // update hunger
@@ -148,9 +147,9 @@ void StatusBarsView::api(char* message)
             float maxHunger = *(float*)(message + 1);
             float hunger = *(float*)(message + 5);
             this->hunger = hunger / maxHunger;
-            lockZeichnung();
+            lockDrawable();
             hungerText = (int)ceil(hunger);
-            unlockZeichnung();
+            unlockDrawable();
             break;
         }
     case 4: // update thirst
@@ -158,100 +157,98 @@ void StatusBarsView::api(char* message)
             float maxThirst = *(float*)(message + 1);
             float thirst = *(float*)(message + 5);
             this->thirst = thirst / maxThirst;
-            lockZeichnung();
+            lockDrawable();
             thirstText = (int)ceil(thirst);
-            unlockZeichnung();
+            unlockDrawable();
             break;
         }
     }
     setRender();
 }
 
-void StatusBarsView::render(Framework::Bild& rObj)
+void StatusBarsView::render(Framework::Image& rObj)
 {
-    ZeichnungHintergrund::render(rObj);
-    if (!rObj.setDrawOptions(pos.x + getRahmenBreite(),
-            pos.y + getRahmenBreite(),
-            gr.x - getRahmenBreite() * 2,
-            gr.y - getRahmenBreite() * 2))
+    DrawableBackground::render(rObj);
+    if (!rObj.setDrawOptions(pos.x + getBorderWidth(),
+            pos.y + getBorderWidth(),
+            gr.x - getBorderWidth() * 2,
+            gr.y - getBorderWidth() * 2))
         return;
-    rObj.alphaBild(0, 0, 20, 20, *healthIcon);
-    rObj.alphaBild(gr.x - getRahmenBreite() * 2 - 20, 10, 20, 20, *energyIcon);
-    rObj.alphaBild(0, 20, 20, 20, *hungerIcon);
-    rObj.alphaBild(gr.x - getRahmenBreite() * 2 - 20, 30, 20, 20, *thirstIcon);
-    lockZeichnung();
+    rObj.alphaImage(0, 0, 20, 20, *healthIcon);
+    rObj.alphaImage(gr.x - getBorderWidth() * 2 - 20, 10, 20, 20, *energyIcon);
+    rObj.alphaImage(0, 20, 20, 20, *hungerIcon);
+    rObj.alphaImage(gr.x - getBorderWidth() * 2 - 20, 30, 20, 20, *thirstIcon);
+    lockDrawable();
     tr.renderText(25, 4, healthText, rObj, 0xFFFFFFFF);
     tr.renderText(25, 24, hungerText, rObj, 0xFFFFFFFF);
     int leftTxtBr
-        = MAX(tr.getTextBreite(healthText), tr.getTextBreite(hungerText));
+        = MAX(tr.getTextWidth(healthText), tr.getTextWidth(hungerText));
     int rightTxtBr
-        = MAX(tr.getTextBreite(energyText), tr.getTextBreite(thirstText));
-    tr.renderText(gr.x - getRahmenBreite() * 2 - 25 - rightTxtBr,
+        = MAX(tr.getTextWidth(energyText), tr.getTextWidth(thirstText));
+    tr.renderText(gr.x - getBorderWidth() * 2 - 25 - rightTxtBr,
         14,
         energyText,
         rObj,
         0xFFFFFFFF);
-    tr.renderText(gr.x - getRahmenBreite() * 2 - 25 - rightTxtBr,
+    tr.renderText(gr.x - getBorderWidth() * 2 - 25 - rightTxtBr,
         34,
         thirstText,
         rObj,
         0xFFFFFFFF);
-    unlockZeichnung();
-    int leftWidth = gr.x - 62 - leftTxtBr - getRahmenBreite() * 2 - rightTxtBr;
+    unlockDrawable();
+    int leftWidth = gr.x - 62 - leftTxtBr - getBorderWidth() * 2 - rightTxtBr;
     if (leftWidth > 0)
     {
-        rObj.drawLinieVAlpha(30 + leftTxtBr, 0, gr.y, 0xA052525E);
-        rObj.drawLinieVAlpha(gr.x - getRahmenBreite() * 2 - 31 - rightTxtBr,
-            0,
-            gr.y,
-            0xA052525E);
+        rObj.drawLineVAlpha(30 + leftTxtBr, 0, gr.y, 0xA052525E);
+        rObj.drawLineVAlpha(
+            gr.x - getBorderWidth() * 2 - 31 - rightTxtBr, 0, gr.y, 0xA052525E);
 
         for (int i = 0; i <= 6; i++)
-            rObj.drawLinieHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
+            rObj.drawLineHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
         for (int i = 13; i <= 16; i++)
-            rObj.drawLinieHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
+            rObj.drawLineHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
         for (int i = 23; i <= 22; i++)
-            rObj.drawLinieHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
+            rObj.drawLineHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
         for (int i = 23; i <= 32; i++)
-            rObj.drawLinieHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
+            rObj.drawLineHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
         for (int i = 33; i <= 42; i++)
-            rObj.drawLinieHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
+            rObj.drawLineHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
         for (int i = 43; i <= 49; i++)
-            rObj.drawLinieHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
+            rObj.drawLineHAlpha(30 + leftTxtBr + 1, i, leftWidth, 0xA052525E);
         for (int i = 0; i < 6; i++)
         {
-            rObj.drawLinieH(30 + leftTxtBr + 1,
+            rObj.drawLineH(30 + leftTxtBr + 1,
                 7 + i,
                 (int)((float)leftWidth * health),
                 0xFFB9180C);
-            rObj.drawLinieHAlpha(
+            rObj.drawLineHAlpha(
                 30 + leftTxtBr + 1 + (int)((float)leftWidth * health),
                 7 + i,
                 leftWidth - (int)((float)leftWidth * health),
                 0xA052525E);
-            rObj.drawLinieH(30 + leftTxtBr + 1,
+            rObj.drawLineH(30 + leftTxtBr + 1,
                 17 + i,
                 (int)((float)leftWidth * energy),
                 0xFFF0C800);
-            rObj.drawLinieHAlpha(
+            rObj.drawLineHAlpha(
                 30 + leftTxtBr + 1 + (int)((float)leftWidth * energy),
                 17 + i,
                 leftWidth - (int)((float)leftWidth * energy),
                 0xA052525E);
-            rObj.drawLinieH(30 + leftTxtBr + 1,
+            rObj.drawLineH(30 + leftTxtBr + 1,
                 27 + i,
                 (int)((float)leftWidth * hunger),
                 0xFF008300);
-            rObj.drawLinieHAlpha(
+            rObj.drawLineHAlpha(
                 30 + leftTxtBr + 1 + (int)((float)leftWidth * hunger),
                 27 + i,
                 leftWidth - (int)((float)leftWidth * hunger),
                 0xA052525E);
-            rObj.drawLinieH(30 + leftTxtBr + 1,
+            rObj.drawLineH(30 + leftTxtBr + 1,
                 37 + i,
                 (int)((float)leftWidth * thirst),
                 0xFF0018FF);
-            rObj.drawLinieHAlpha(
+            rObj.drawLineHAlpha(
                 30 + leftTxtBr + 1 + (int)((float)leftWidth * thirst),
                 37 + i,
                 leftWidth - (int)((float)leftWidth * thirst),

FactoryCraft/StatusBars.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Schrift.h>
+#include <Font.h>
 #include <UIMLView.h>
 
 #include "InventoryView.h"
@@ -13,21 +13,21 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class StatusBarsView : public Framework::ZeichnungHintergrund,
+class StatusBarsView : public Framework::DrawableBackground,
                        public NetworkAPIProcessor
 {
 private:
@@ -41,15 +41,15 @@ private:
     Framework::Text hungerText;
     Framework::Text thirstText;
     Framework::Text energyText;
-    Framework::Bild* healthIcon;
-    Framework::Bild* hungerIcon;
-    Framework::Bild* thirstIcon;
-    Framework::Bild* energyIcon;
+    Framework::Image* healthIcon;
+    Framework::Image* hungerIcon;
+    Framework::Image* thirstIcon;
+    Framework::Image* energyIcon;
     Framework::TextRenderer tr;
 
 public:
     StatusBarsView(Framework::Text id, int targetEntity);
     ~StatusBarsView();
     void api(char* message) override;
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };

FactoryCraft/TransparentChunkGroundModel.cpp

@@ -91,7 +91,7 @@ void TransparentChunkGroundModel::buildModel()
 {
     Model3DData* chunkModel = target->zModelData();
     // remove old model
-    while (chunkModel->getPolygonAnzahl() > 0)
+    while (chunkModel->getPolygonCount() > 0)
     {
         chunkModel->removePolygon(0);
     }
@@ -182,7 +182,7 @@ void TransparentChunkGroundModel::buildModel()
             }
         }
     }
-    Model3DTextur* textur = new Model3DTextur();
+    Model3DTexture* texture = new Model3DTexture();
     int pi = 0;
     for (GroundModelPart* part : groundPartArray)
     {
@@ -190,14 +190,14 @@ void TransparentChunkGroundModel::buildModel()
         polygon->indexAnz = part->indexCount;
         polygon->indexList = part->indexList;
         target->zModelData()->addPolygon(polygon);
-        textur->setPolygonTextur(pi,
-            uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTextur(
+        texture->setPolygonTexture(pi,
+            uiFactory.initParam.bildschirm->zGraphicsApi()->createOrGetTexture(
                 part->name));
         pi++;
         delete part;
     }
     target->zModelData()->setVertecies(groundVerticies, groundVertexCount);
-    target->setModelTextur(textur);
+    target->setModelTextur(texture);
     target->setVertexLightBuffer(lightBuffer, groundVertexCount);
 }
 
@@ -239,5 +239,5 @@ bool TransparentChunkGroundModel::isTransparent() const
 
 bool TransparentChunkGroundModel::isPartOfModel(Block* zBlock) const
 {
-    return zBlock->getCurrentModelInfo().getModelName().istGleich("grass");
+    return zBlock->getCurrentModelInfo().getModelName().isEqual("grass");
 }

FactoryCraft/UIMLCraftingProgress.cpp

@@ -11,10 +11,10 @@ UIMLCraftingProgressElement::UIMLCraftingProgressElement()
 bool UIMLCraftingProgressElement::isApplicableFor(
     Framework::XML::Element& element)
 {
-    return element.getName().istGleich("craftingProgress");
+    return element.getName().isEqual("craftingProgress");
 }
 
-Framework::Zeichnung* UIMLCraftingProgressElement::parseElement(
+Framework::Drawable* UIMLCraftingProgressElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     int addressLength = 0;
@@ -31,13 +31,13 @@ Framework::Zeichnung* UIMLCraftingProgressElement::parseElement(
             "Progress: ",
             " ticks");
     Framework::Text direction = element.getAttributeValue("direction");
-    view->setStyle(UIMLProgressAndStateView::Style::Sichtbar
-                   | UIMLProgressAndStateView::Style::Erlaubt);
-    if (direction.istGleich("TOP") || direction.istGleich("BOTTOM"))
+    view->setStyle(UIMLProgressAndStateView::Style::Visible
+                   | UIMLProgressAndStateView::Style::Allowed);
+    if (direction.isEqual("TOP") || direction.isEqual("BOTTOM"))
     {
         view->addStyle(UIMLProgressAndStateView::Style::Vertical);
     }
-    if (direction.istGleich("TOP") || direction.istGleich("LEFT"))
+    if (direction.isEqual("TOP") || direction.isEqual("LEFT"))
     {
         view->addStyle(UIMLProgressAndStateView::Style::Reversed);
     }
@@ -46,7 +46,7 @@ Framework::Zeichnung* UIMLCraftingProgressElement::parseElement(
 
 bool UIMLCraftingProgressElement::updateElement(
     Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false; // No update needed for this element

FactoryCraft/UIMLCraftingProgress.h

@@ -10,10 +10,10 @@ public:
     UIMLCraftingProgressElement();
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
 };

FactoryCraft/UIMLFuelState.cpp

@@ -10,10 +10,10 @@ UIMLFuelStateElement::UIMLFuelStateElement()
 
 bool UIMLFuelStateElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("fuelState");
+    return element.getName().isEqual("fuelState");
 }
 
-Framework::Zeichnung* UIMLFuelStateElement::parseElement(
+Framework::Drawable* UIMLFuelStateElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     int addressLength = 0;
@@ -30,13 +30,13 @@ Framework::Zeichnung* UIMLFuelStateElement::parseElement(
             "Fuel: ",
             "");
     Framework::Text direction = element.getAttributeValue("direction");
-    view->setStyle(UIMLProgressAndStateView::Style::Sichtbar
-                   | UIMLProgressAndStateView::Style::Erlaubt);
-    if (direction.istGleich("TOP") || direction.istGleich("BOTTOM"))
+    view->setStyle(UIMLProgressAndStateView::Style::Visible
+                   | UIMLProgressAndStateView::Style::Allowed);
+    if (direction.isEqual("TOP") || direction.isEqual("BOTTOM"))
     {
         view->addStyle(UIMLProgressAndStateView::Style::Vertical);
     }
-    if (direction.istGleich("TOP") || direction.istGleich("LEFT"))
+    if (direction.isEqual("TOP") || direction.isEqual("LEFT"))
     {
         view->addStyle(UIMLProgressAndStateView::Style::Reversed);
     }
@@ -44,7 +44,7 @@ Framework::Zeichnung* UIMLFuelStateElement::parseElement(
 }
 
 bool UIMLFuelStateElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false; // No update needed for this element

FactoryCraft/UIMLFuelState.h

@@ -8,10 +8,10 @@ public:
     UIMLFuelStateElement();
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
 };

FactoryCraft/UIMLProgressAndStateView.cpp

@@ -1,8 +1,8 @@
 #include "UIMLProgressAndStateView.h"
 
-#include <Bild.h>
-#include <DateiSystem.h>
-#include <TextFeld.h>
+#include <Image.h>
+#include <FileSystem.h>
+#include <TextField.h>
 #include <ToolTip.h>
 
 #include "Globals.h"
@@ -18,7 +18,7 @@ UIMLProgressAndStateView::UIMLProgressAndStateView(Framework::Text id,
     char unregisterMessage,
     Framework::Text toolTipPrefix,
     Framework::Text toolTipSuffix)
-    : Framework::Zeichnung(),
+    : Framework::Drawable(),
       NetworkAPIProcessor(),
       id(id),
       background(0),
@@ -32,17 +32,17 @@ UIMLProgressAndStateView::UIMLProgressAndStateView(Framework::Text id,
       max(0),
       current(0)
 {
-    Framework::LTDBDatei file;
-    file.setDatei(
-        background.getTeilText(0, background.positionVon(".ltdb/") + 5));
-    file.leseDaten(0);
-    this->background = file.laden(
-        0, background.getTeilText(background.positionVon(".ltdb/") + 6));
-    file.setDatei(
-        foreground.getTeilText(0, foreground.positionVon(".ltdb/") + 5));
-    file.leseDaten(0);
-    this->foreground = file.laden(
-        0, foreground.getTeilText(foreground.positionVon(".ltdb/") + 6));
+    Framework::LTDBFile file;
+    file.setFile(
+        background.getTeilText(0, background.positionOf(".ltdb/") + 5));
+    file.readData(0);
+    this->background = file.load(
+        0, background.getTeilText(background.positionOf(".ltdb/") + 6));
+    file.setFile(
+        foreground.getTeilText(0, foreground.positionOf(".ltdb/") + 5));
+    file.readData(0);
+    this->foreground = file.load(
+        0, foreground.getTeilText(foreground.positionOf(".ltdb/") + 6));
     char* msg = new char[id.getLength() + 6];
     msg[0] = registerMessage; // register progress/state observer
     msg[1] = (char)id.getLength();
@@ -79,7 +79,7 @@ void UIMLProgressAndStateView::api(char* message)
     max = *(int*)message;
     current = *(int*)(message + 4);
     uiFactory.initParam.bildschirm->lock();
-    lockZeichnung();
+    lockDrawable();
     Framework::Text toolTipText;
     toolTipText.append() << toolTipPrefix.getText() << current << " / " << max
                          << toolTipSuffix;
@@ -87,12 +87,12 @@ void UIMLProgressAndStateView::api(char* message)
     {
         setToolTipText(toolTipText,
             uiFactory.initParam.bildschirm,
-            uiFactory.initParam.schrift);
+            uiFactory.initParam.font);
     }
     else
     {
-        Framework::TextFeld* textField
-            = dynamic_cast<Framework::TextFeld*>(toolTip->zMember(0));
+        Framework::TextField* textField
+            = dynamic_cast<Framework::TextField*>(toolTip->zMember(0));
         if (textField)
         {
             textField->setText(toolTipText);
@@ -103,62 +103,62 @@ void UIMLProgressAndStateView::api(char* message)
         {
             setToolTipText(toolTipText,
                 uiFactory.initParam.bildschirm,
-                uiFactory.initParam.schrift);
+                uiFactory.initParam.font);
         }
     }
     toolTip->setRender();
     rend = 1;
-    unlockZeichnung();
+    unlockDrawable();
     uiFactory.initParam.bildschirm->unlock();
 }
 
-void UIMLProgressAndStateView::render(Framework::Bild& rObj)
+void UIMLProgressAndStateView::render(Framework::Image& rObj)
 {
-    if (hatStyleNicht(Style::Sichtbar)) return;
-    lockZeichnung();
+    if (hasStyleNot(Style::Visible)) return;
+    lockDrawable();
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y))
     {
-        unlockZeichnung();
+        unlockDrawable();
         return;
     }
-    Zeichnung::render(rObj);
-    rObj.alphaBild(0, 0, gr.x, gr.y, *background);
+    Drawable::render(rObj);
+    rObj.alphaImage(0, 0, gr.x, gr.y, *background);
     if (max > 0 && current > 0)
     {
         double progrss = (double)current / max;
-        if (hatStyle(Style::Vertical))
+        if (hasStyle(Style::Vertical))
         {
             int height = (int)(gr.y * progrss);
-            if (hatStyle(Style::Reversed))
+            if (hasStyle(Style::Reversed))
             {
                 if (rObj.setDrawOptions(0, gr.y - height, gr.x, height))
                 {
-                    rObj.alphaBild(0, height - gr.y, gr.x, gr.y, *foreground);
+                    rObj.alphaImage(0, height - gr.y, gr.x, gr.y, *foreground);
                     rObj.releaseDrawOptions();
                 }
             }
             else
             {
-                rObj.alphaBild(0, 0, gr.x, height, *foreground);
+                rObj.alphaImage(0, 0, gr.x, height, *foreground);
             }
         }
         else
         {
             int width = (int)(gr.x * progrss);
-            if (hatStyle(Style::Reversed))
+            if (hasStyle(Style::Reversed))
             {
                 if (rObj.setDrawOptions(gr.x - width, 0, width, gr.y))
                 {
-                    rObj.alphaBild(width - gr.x, 0, gr.x, gr.y, *foreground);
+                    rObj.alphaImage(width - gr.x, 0, gr.x, gr.y, *foreground);
                     rObj.releaseDrawOptions();
                 }
             }
             else
             {
-                rObj.alphaBild(0, 0, width, gr.y, *foreground);
+                rObj.alphaImage(0, 0, width, gr.y, *foreground);
             }
         }
     }
     rObj.releaseDrawOptions();
-    unlockZeichnung();
+    unlockDrawable();
 }

FactoryCraft/UIMLProgressAndStateView.h

@@ -1,15 +1,15 @@
 #pragma once
 
 #include <Text.h>
-#include <Zeichnung.h>
+#include <Drawing.h>
 
 #include "NetworkAPIProcessor.h"
 
-class UIMLProgressAndStateView : public Framework::Zeichnung,
+class UIMLProgressAndStateView : public Framework::Drawable,
                                  public NetworkAPIProcessor
 {
 public:
-    class Style : public Framework::Zeichnung::Style
+    class Style : public Framework::Drawable::Style
     {
     public:
         static const __int64 Vertical = 0x100;
@@ -18,8 +18,8 @@ public:
 
 private:
     Framework::Text id;
-    Framework::Bild* background;
-    Framework::Bild* foreground;
+    Framework::Image* background;
+    Framework::Image* foreground;
     char registerMessage;
     char unregisterMessage;
     Framework::Text toolTipPrefix;
@@ -41,5 +41,5 @@ public:
         Framework::Text toolTipSuffix);
     ~UIMLProgressAndStateView();
     void api(char* message) override;
-    void render(Framework::Bild& rObj) override;
+    void render(Framework::Image& rObj) override;
 };

FactoryCraft/UIMLToolTip.cpp

@@ -5,18 +5,18 @@
 using namespace Framework;
 
 UIMLToolTip::UIMLToolTip()
-    : ToolTip(window->zBildschirm())
+    : ToolTip(window->zScreen())
 {
     view = new UIMLView("", uiFactory);
     addMember(view);
-    view->setStyle(UIMLView::Style::Sichtbar);
-    addStyle(ZeichnungHintergrund::Style::Hintergrund
-             | ZeichnungHintergrund::Style::HAlpha
-             | ZeichnungHintergrund::Style::Rahmen
-             | ZeichnungHintergrund::Style::Sichtbar);
-    setHintergrundFarbe(0xA0000000);
-    setRahmenFarbe(0xFFFFFFFF);
-    setRahmenBreite(1);
+    view->setStyle(UIMLView::Style::Visible);
+    addStyle(DrawableBackground::Style::Background
+             | DrawableBackground::Style::BAlpha
+             | DrawableBackground::Style::Border
+             | DrawableBackground::Style::Visible);
+    setBackgroundColor(0xA0000000);
+    setBorderColor(0xFFFFFFFF);
+    setBorderWidth(1);
 }
 
 UIMLToolTip::~UIMLToolTip() {}

FactoryCraft/UIMLUtils.cpp

@@ -3,20 +3,20 @@
 int* getUIMLTargetAddress(Framework::Text address, int& addressLength)
 {
     int* result = 0;
-    if (address.hat(','))
+    if (address.has(','))
     {
         Framework::Text* part1
-            = address.getTeilText(0, address.positionVon(",", 0) + 1);
+            = address.getTeilText(0, address.positionOf(",", 0) + 1);
         Framework::Text* part2 = address.getTeilText(
-            address.positionVon(",", 0) + 1, address.positionVon(",", 1));
+            address.positionOf(",", 0) + 1, address.positionOf(",", 1));
         Framework::Text* part3 = address.getTeilText(
-            address.positionVon(",", 1) + 1, address.positionVon(",", 2));
-        if (address.hat(":"))
+            address.positionOf(",", 1) + 1, address.positionOf(",", 2));
+        if (address.has(":"))
         {
             Framework::Text* part4 = address.getTeilText(
-                address.positionVon(",", 2) + 1, address.positionVon(":"));
+                address.positionOf(",", 2) + 1, address.positionOf(":"));
             Framework::Text* part5
-                = address.getTeilText(address.positionVon(":") + 1);
+                = address.getTeilText(address.positionOf(":") + 1);
             addressLength = 5;
             result = new int[5];
             result[4] = (int)*part5;
@@ -27,7 +27,7 @@ int* getUIMLTargetAddress(Framework::Text address, int& addressLength)
         else
         {
             Framework::Text* part4
-                = address.getTeilText(address.positionVon(",", 2) + 1);
+                = address.getTeilText(address.positionOf(",", 2) + 1);
             addressLength = 4;
             result = new int[4];
             result[3] = (int)*part4;
@@ -42,12 +42,12 @@ int* getUIMLTargetAddress(Framework::Text address, int& addressLength)
     }
     else
     {
-        if (address.hat(":"))
+        if (address.has(":"))
         {
             Framework::Text* part1
-                = address.getTeilText(0, address.positionVon(":"));
+                = address.getTeilText(0, address.positionOf(":"));
             Framework::Text* part2
-                = address.getTeilText(address.positionVon(":") + 1);
+                = address.getTeilText(address.positionOf(":") + 1);
             addressLength = 2;
             result = new int[2];
             result[0] = (int)*part1;

FactoryCraft/UnshapedRecipie.cpp

@@ -1,6 +1,6 @@
 #include "UnshapedRecipie.h"
 
-#include <Bild.h>
+#include <Image.h>
 #include <XML.h>
 
 UnshapedRecipieElement::UnshapedRecipieElement()
@@ -11,12 +11,12 @@ UnshapedRecipieElement::UnshapedRecipieElement()
 //! ist
 bool UnshapedRecipieElement::isApplicableFor(Framework::XML::Element& element)
 {
-    return element.getName().istGleich("recipie")
-        && element.getAttributeValue("type").istGleich("unshaped");
+    return element.getName().isEqual("recipie")
+        && element.getAttributeValue("type").isEqual("unshaped");
 }
 
-//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-Framework::Zeichnung* UnshapedRecipieElement::parseElement(
+//! erstellt eine neue Drawable zu einem gegebenen xml Element
+Framework::Drawable* UnshapedRecipieElement::parseElement(
     Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
 {
     UnshapedRecipie* recipie = new UnshapedRecipie();
@@ -38,15 +38,15 @@ Framework::Zeichnung* UnshapedRecipieElement::parseElement(
 }
 
 bool UnshapedRecipieElement::updateElement(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     Framework::UIMLContainer& generalFactory)
 {
     return false;
 }
 
-//! wendet die layout parameter zu einer Zeichnung an
+//! wendet die layout parameter zu einer Drawable an
 void UnshapedRecipieElement::layout(Framework::XML::Element& element,
-    Framework::Zeichnung& z,
+    Framework::Drawable& z,
     int pWidth,
     int pHeight,
     Framework::UIMLContainer& generalLayouter)
@@ -54,17 +54,17 @@ void UnshapedRecipieElement::layout(Framework::XML::Element& element,
     UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
     element.selectChildren().selectChildren().forEach(
         [&z, &generalLayouter](Framework::XML::Element* zElement) {
-            Framework::Zeichnung* child = 0;
+            Framework::Drawable* child = 0;
             if (zElement->hasAttribute("id"))
             {
-                child = generalLayouter.zZeichnungById(
+                child = generalLayouter.zDrawableById(
                     zElement->getAttributeValue("id"));
             }
             if (child)
             {
                 generalLayouter.layout(*zElement,
                     *child,
-                    z.getBreite(),
+                    z.getWidth(),
                     z.getHeight(),
                     generalLayouter);
             }
@@ -72,18 +72,18 @@ void UnshapedRecipieElement::layout(Framework::XML::Element& element,
 }
 
 UnshapedRecipie::UnshapedRecipie()
-    : Framework::ZeichnungHintergrund()
+    : Framework::DrawableBackground()
 {
-    setStyle(Framework::Zeichnung::Style::Erlaubt
-             | Framework::Zeichnung::Style::Sichtbar);
+    setStyle(Framework::Drawable::Style::Allowed
+             | Framework::Drawable::Style::Visible);
 }
 
-void UnshapedRecipie::addIngredient(Zeichnung* ingredient)
+void UnshapedRecipie::addIngredient(Drawable* ingredient)
 {
     ingredients.add(ingredient);
 }
 
-void UnshapedRecipie::addOutput(Zeichnung* output)
+void UnshapedRecipie::addOutput(Drawable* output)
 {
     outputs.add(output);
 }
@@ -91,26 +91,26 @@ void UnshapedRecipie::addOutput(Zeichnung* output)
 bool UnshapedRecipie::tick(double tickVal)
 {
     bool ret = false;
-    for (Zeichnung* ingredient : ingredients)
+    for (Drawable* ingredient : ingredients)
     {
         ret |= ingredient->tick(tickVal);
     }
-    for (Zeichnung* output : outputs)
+    for (Drawable* output : outputs)
     {
         ret |= output->tick(tickVal);
     }
     return ret;
 }
 
-void UnshapedRecipie::render(Framework::Bild& rObj)
+void UnshapedRecipie::render(Framework::Image& rObj)
 {
-    if (!hatStyle(Zeichnung::Style::Sichtbar)) return;
-    ZeichnungHintergrund::render(rObj);
+    if (!hasStyle(Drawable::Style::Visible)) return;
+    DrawableBackground::render(rObj);
     if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
     int x = 0;
     int y = 0;
-    int width = MIN(3, ingredients.getEintragAnzahl());
-    for (Zeichnung* ingredient : ingredients)
+    int width = MIN(3, ingredients.getEntryCount());
+    for (Drawable* ingredient : ingredients)
     {
         ingredient->setX(x);
         ingredient->setY(y);
@@ -123,36 +123,36 @@ void UnshapedRecipie::render(Framework::Bild& rObj)
         }
     }
     rObj.fillRegion(width * 60, gr.y / 2 - 5, 25, 10, 0xFF52525E);
-    rObj.drawDreieck(Framework::Punkt(3 * 60 + 25, gr.y / 2 - 15),
-        Framework::Punkt(width * 60 + 40, gr.y / 2),
-        Framework::Punkt(width * 60 + 25, gr.y / 2 + 15),
+    rObj.drawTriangle(Framework::Point(3 * 60 + 25, gr.y / 2 - 15),
+        Framework::Point(width * 60 + 40, gr.y / 2),
+        Framework::Point(width * 60 + 25, gr.y / 2 + 15),
         0xFF52525E);
     x = width * 60 + 50;
     int oldy = y;
     y = 0;
-    for (Zeichnung* output : outputs)
+    for (Drawable* output : outputs)
     {
         output->setX(x);
         output->setY(y);
         output->render(rObj);
         y += 60;
     }
-    int height = MAX(3, outputs.getEintragAnzahl());
-    if (getBreite() != width * 60 + 50 + 50 && getHeight() != height)
+    int height = MAX(3, outputs.getEntryCount());
+    if (getWidth() != width * 60 + 50 + 50 && getHeight() != height)
     {
         setSize(width * 60 + 50 + 50, MAX(oldy + 50, y + 50));
     }
     rObj.releaseDrawOptions();
 }
 
-void UnshapedRecipie::doMausEreignis(Framework::MausEreignis& me, bool userRet)
+void UnshapedRecipie::doMouseEvent(Framework::MouseEvent& me, bool userRet)
 {
-    for (Zeichnung* ingredient : ingredients)
+    for (Drawable* ingredient : ingredients)
     {
-        ingredient->doPublicMausEreignis(me);
+        ingredient->doPublicMouseEvent(me);
     }
-    for (Zeichnung* output : outputs)
+    for (Drawable* output : outputs)
     {
-        output->doPublicMausEreignis(me);
+        output->doPublicMouseEvent(me);
     }
 }

FactoryCraft/UnshapedRecipie.h

@@ -9,31 +9,31 @@ public:
     //! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
     //! ist
     bool isApplicableFor(Framework::XML::Element& element) override;
-    //! erstellt eine neue Zeichnung zu einem gegebenen xml Element
-    Framework::Zeichnung* parseElement(Framework::XML::Element& element,
+    //! erstellt eine neue Drawable zu einem gegebenen xml Element
+    Framework::Drawable* parseElement(Framework::XML::Element& element,
         Framework::UIMLContainer& generalFactory) override;
     bool updateElement(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         Framework::UIMLContainer& generalFactory) override;
-    //! wendet die layout parameter zu einer Zeichnung an
+    //! wendet die layout parameter zu einer Drawable an
     void layout(Framework::XML::Element& element,
-        Framework::Zeichnung& z,
+        Framework::Drawable& z,
         int pWidth,
         int pHeight,
         Framework::UIMLContainer& generalLayouter) override;
 };
 
-class UnshapedRecipie : public Framework::ZeichnungHintergrund
+class UnshapedRecipie : public Framework::DrawableBackground
 {
 private:
-    Framework::RCArray<Zeichnung> ingredients;
-    Framework::RCArray<Zeichnung> outputs;
+    Framework::RCArray<Drawable> ingredients;
+    Framework::RCArray<Drawable> outputs;
 
 public:
     UnshapedRecipie();
-    void addIngredient(Zeichnung* ingredient);
-    void addOutput(Zeichnung* output);
+    void addIngredient(Drawable* ingredient);
+    void addOutput(Drawable* output);
     bool tick(double tickVal) override;
-    void render(Framework::Bild& rObj) override;
-    void doMausEreignis(Framework::MausEreignis& me, bool userRet) override;
+    void render(Framework::Image& rObj) override;
+    void doMouseEvent(Framework::MouseEvent& me, bool userRet) override;
 };

FactoryCraft/World.cpp

@@ -5,7 +5,7 @@
 #include <GraphicsApi.h>
 #include <iostream>
 #include <Network.h>
-#include <Welt3D.h>
+#include <World3D.h>
 
 #include "Constants.h"
 #include "Game.h"
@@ -16,12 +16,12 @@ using namespace Framework;
 
 World* World::INSTANCE = 0;
 
-World::World(Bildschirm3D* zScreen, FactoryClient* client)
+World::World(Screen3D* zScreen, FactoryClient* client)
     : Thread(),
       client(client)
 {
     zScreen->lock();
-    renderedWorld = new Welt3D();
+    renderedWorld = new World3D();
     renderedWorld->addDiffuseLight(DiffuseLight{
         Vec3<float>(0.5f, 0.5f, -1.f), Vec3<float>(1.f, 1.f, 1.f)});
     currentDimension = new Dimension();
@@ -29,7 +29,7 @@ World::World(Bildschirm3D* zScreen, FactoryClient* client)
         dynamic_cast<Model3DCollection*>(currentDimension->getThis()));
     zScreenPtr = zScreen;
     kam = new PlayerKam(zScreen);
-    kam->setWelt(renderedWorld);
+    kam->setWorld(renderedWorld);
     zScreen->addKamera(kam);
     firstMessage = 1;
     ownEntityId = -1;
@@ -46,23 +46,23 @@ World::World(Bildschirm3D* zScreen, FactoryClient* client)
     *(int*)data = 0xFFFFFF00;
     fallbackVertexLightBuffer->setData(data);
     fallbackVertexLightBuffer->setLength(16);
-    fallbackVertexLightBuffer->copieren();
+    fallbackVertexLightBuffer->copyToGPU();
     selectionModel = new FactoryCraftModel();
-    selectionModel->setModelDaten(zScreen->zGraphicsApi()->getModel("cube"));
+    selectionModel->setModelData(zScreen->zGraphicsApi()->getModel("cube"));
     selectionModel->setSize(1.005f);
     selectionModel->setVisible(0);
     unsigned char light[3] = {0xff, 0xff, 0xff};
     selectionModel->setAverageLight(light);
-    selectionModel->setModelTextur(new Model3DTextur());
+    selectionModel->setModelTextur(new Model3DTexture());
     for (int i = 0; i < 6; i++)
     {
-        selectionModel->zTextur()->setPolygonTextur(i,
-            zScreen->zGraphicsApi()->createOrGetTextur(
+        selectionModel->zTexture()->setPolygonTexture(i,
+            zScreen->zGraphicsApi()->createOrGetTexture(
                 "data/textures/blocks.ltdb/selectedblock.p"));
     }
     selectionModel->setAlpha(1);
     selectionModel->setUseEffectAlpha(1);
-    renderedWorld->addZeichnung(selectionModel);
+    renderedWorld->addDrawable(selectionModel);
     zScreen->unlock();
     start();
 }
@@ -85,13 +85,13 @@ void World::update(bool background)
                ? serverMessageReader = client->getNextBackgroundMessage()
                : serverMessageReader = client->getNextForegroundMessage())
     {
-        serverMessageReader->lese((char*)&type, 1);
+        serverMessageReader->read((char*)&type, 1);
         if (type == 3) // API MESSAGE
         {
             int length;
-            serverMessageReader->lese((char*)&length, 4);
+            serverMessageReader->read((char*)&length, 4);
             char* data = new char[length];
-            serverMessageReader->lese(data, length);
+            serverMessageReader->read(data, length);
             switch (data[0])
             {
             case 1: // dimension message
@@ -189,9 +189,9 @@ void World::update(bool background)
         if (type == 4) // POSITION UPDATE
         {
             int old = ownEntityId;
-            serverMessageReader->lese((char*)&ownEntityId, 4);
+            serverMessageReader->read((char*)&ownEntityId, 4);
             int dimensionId = 0;
-            serverMessageReader->lese((char*)&dimensionId, 4);
+            serverMessageReader->read((char*)&dimensionId, 4);
             currentDimension->setId(dimensionId);
             kam->setEntityId(ownEntityId);
             Entity* p = zEntity(ownEntityId);
@@ -207,22 +207,22 @@ void World::update(bool background)
         renderedWorld->lock();
         currentDimension->removeDistantChunks(
             {(int)player->getPos().x, (int)player->getPos().y});
-        Punkt currentChunk
+        Point currentChunk
             = getChunkCenter((int)player->getX(), (int)player->getY());
         for (int x = 0; x <= CHUNK_VISIBILITY_RANGE; x++)
         {
             for (int y = 0; y <= CHUNK_VISIBILITY_RANGE; y++)
             {
-                std::function<void(Punkt)> requestChunk = [this](Punkt center) {
+                std::function<void(Point)> requestChunk = [this](Point center) {
                     Chunk* zC = currentDimension->zChunk(center);
                     if (!zC)
                     {
                         char msg[1];
                         msg[0] = 0; // add observer and request chaunk data
-                        Punkt pos = center;
+                        Point pos = center;
                         subLock.lock();
                         bool found = 0;
-                        for (Punkt p : subscriptions)
+                        for (Point p : subscriptions)
                         {
                             if (p == pos)
                             {
@@ -239,17 +239,17 @@ void World::update(bool background)
                     }
                 };
                 requestChunk(
-                    currentChunk + Punkt(x * CHUNK_SIZE, y * CHUNK_SIZE));
+                    currentChunk + Point(x * CHUNK_SIZE, y * CHUNK_SIZE));
                 if (y > 0)
                     requestChunk(
-                        currentChunk + Punkt(x * CHUNK_SIZE, -y * CHUNK_SIZE));
+                        currentChunk + Point(x * CHUNK_SIZE, -y * CHUNK_SIZE));
                 if (x > 0)
                 {
                     requestChunk(
-                        currentChunk + Punkt(-x * CHUNK_SIZE, y * CHUNK_SIZE));
+                        currentChunk + Point(-x * CHUNK_SIZE, y * CHUNK_SIZE));
                     if (y > 0)
                         requestChunk(currentChunk
-                                     + Punkt(-x * CHUNK_SIZE, -y * CHUNK_SIZE));
+                                     + Point(-x * CHUNK_SIZE, -y * CHUNK_SIZE));
                 }
             }
         }
@@ -389,16 +389,16 @@ void World::setVisibility(Entity* zEntity, bool visible)
 {
     renderedWorld->lock();
     if (visible)
-        renderedWorld->addZeichnung(
+        renderedWorld->addDrawable(
             dynamic_cast<Framework::Model3D*>(zEntity->getThis()));
     else
-        renderedWorld->removeZeichnung(zEntity);
+        renderedWorld->removeDrawable(zEntity);
     renderedWorld->unlock();
 }
 
-Framework::Punkt World::getChunkCenter(int x, int y) const
+Framework::Point World::getChunkCenter(int x, int y) const
 {
-    return Punkt(((x < 0 ? x + 1 : x) / CHUNK_SIZE) * CHUNK_SIZE
+    return Point(((x < 0 ? x + 1 : x) / CHUNK_SIZE) * CHUNK_SIZE
                      + (x < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2,
         ((y < 0 ? y + 1 : y) / CHUNK_SIZE) * CHUNK_SIZE
             + (y < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2);
@@ -491,11 +491,11 @@ void World::unlockWorld()
     renderedWorld->unlock();
 }
 
-void World::onChunkAdded(Punkt pos)
+void World::onChunkAdded(Point pos)
 {
     subLock.lock();
     int index = 0;
-    for (Punkt p : subscriptions)
+    for (Point p : subscriptions)
     {
         if (p == pos)
         {
@@ -521,7 +521,7 @@ FactoryCraftModel* World::zSelectedEffectModel() const
     return selectionModel;
 }
 
-Chunk* World::zChunk(Punkt center)
+Chunk* World::zChunk(Point center)
 {
     return currentDimension->zChunk(center);
 }

FactoryCraft/World.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <Bildschirm.h>
-#include <Kam3D.h>
+#include <Screen.h>
+#include <Camera3D.h>
 #include <Thread.h>
-#include <Welt3D.h>
+#include <World3D.h>
 
 #include "Dimension.h"
 #include "FactoryClient.h"
@@ -16,13 +16,13 @@ public:
 
 private:
     Dimension* currentDimension;
-    Framework::Welt3D* renderedWorld;
-    Framework::Bildschirm3D* zScreenPtr;
+    Framework::World3D* renderedWorld;
+    Framework::Screen3D* zScreenPtr;
     PlayerKam* kam;
     bool firstMessage;
     int ownEntityId;
     Framework::Model3D* currentTarget;
-    Array<Punkt> subscriptions;
+    Array<Point> subscriptions;
     FactoryClient* client;
     FactoryCraftModel* selectionModel;
     Critical subLock;
@@ -35,7 +35,7 @@ private:
     Framework::DXBuffer* fallbackVertexLightBuffer;
 
 public:
-    World(Framework::Bildschirm3D* zScreen, FactoryClient* client);
+    World(Framework::Screen3D* zScreen, FactoryClient* client);
     ~World();
     void update(bool background);
     void onTick(double time);
@@ -46,7 +46,7 @@ public:
     Block* getBlockAt(Framework::Vec3<int> location) const;
     Dimension* zDimension() const;
     void setVisibility(Entity* zEntity, bool visible);
-    Framework::Punkt getChunkCenter(int x, int y) const;
+    Framework::Point getChunkCenter(int x, int y) const;
     Entity* zEntity(int id) const;
     Entity* getEntity(int id) const;
     void removeEntity(int id);
@@ -56,8 +56,8 @@ public:
     void setTarget(Framework::Model3D* zTarget);
     void lockWorld();
     void unlockWorld();
-    void onChunkAdded(Punkt pos);
-    Chunk* zChunk(Punkt center);
+    void onChunkAdded(Point pos);
+    Chunk* zChunk(Point center);
     Framework::Model3D* getCurrentTarget() const;
     FactoryCraftModel* zSelectedEffectModel() const;
     FactoryClient* zClient() const;