ecere: gfx/gui: add dummy driver named Template to serve as basis for implementing...

diff --git a/ecere/ecere.epj b/ecere/ecere.epj
index 2432b50..eb7276a 100644 (file)
--- a/ecere/ecere.epj
+++ b/ecere/ecere.epj
@@ -1580,7 +1580,8 @@ from wherever you obtained them.
                                  }
                               }
                            ]
-                        }
+                        },
+                        "TemplateDisplayDriver.ec"
                      ],
                      "Options" : {
                         "ExcludeFromBuild" : true
@@ -1914,6 +1915,7 @@ from wherever you obtained them.
                               }
                            ]
                         },
+                        "TemplateInterface.ec",
                         {
                            "FileName" : "EmscriptenInterface.ec",
                            "Configurations" : [

diff --git a/ecere/src/gfx/drivers/TemplateDisplayDriver.ec b/ecere/src/gfx/drivers/TemplateDisplayDriver.ec
new file mode 100644 (file)
index 0000000..d2c9ed0
--- /dev/null
+++ b/ecere/src/gfx/drivers/TemplateDisplayDriver.ec
@@ -0,0 +1,459 @@
+namespace gfx::drivers;
+
+#ifdef BUILDING_ECERE_COM
+import "instance"
+import "Display"
+#else
+#ifdef ECERE_STATIC
+public import static "ecere"
+#else
+public import "ecere"
+#endif
+#endif
+
+import "TemplateInterface"
+
+#if !defined(NO_TEMPLATE_DRIVER)
+
+#include <stdio.h>
+
+// source file line number printf (sflnprintf)
+#define sflnprintf(format,...) printf("%s:% 5d: " format, __FILE__, __LINE__, ##__VA_ARGS__)
+
+class TemplateDisplay : LFBDisplay
+{
+};
+
+class TemplateDisplayDriver : DisplayDriver
+{
+   class_property(name) = "Template";
+
+
+   // Constructor / Destructor
+
+   bool ::CreateDisplaySystem(DisplaySystem displaySystem)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::CreateDisplaySystem [STUB!]\n");
+      return false;
+   }
+
+   void ::DestroyDisplaySystem(DisplaySystem displaySystem)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::DestroyDisplaySystem [STUB!]\n");
+   }
+
+   bool ::CreateDisplay(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::CreateDisplay [STUB!]\n");
+      return false;
+   }
+
+   void ::DestroyDisplay(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::DestroyDisplay [STUB!]\n");
+   }
+
+
+   // Display Position and Size
+
+   bool ::DisplaySize(Display display, int width, int height)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::DisplaySize [STUB!]\n");
+      return false;
+   }
+
+   void ::DisplayPosition(Display display, int x, int y)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::DisplayPosition [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).DisplayPosition(display, x, y);
+   }
+
+
+   // Palettes
+
+   void ::SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SetPalette [STUB!]\n");
+   }
+
+   void ::RestorePalette(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::RestorePalette [STUB!]\n");
+   }
+
+
+   // Display the back buffer content
+
+   void ::StartUpdate(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::StartUpdate [STUB!]\n");
+   }
+
+   void ::EndUpdate(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::EndUpdate [STUB!]\n");
+   }
+
+   void ::Scroll(Display display, Box scroll, int x, int y, Extent dirty)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::Scroll [STUB!]\n");
+   }
+
+   void ::Update(Display display, Box updateBox)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::Update [STUB!]\n");
+   }
+
+
+   // Allocate/free a bitmap
+
+   bool ::AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::AllocateBitmap [STUB!]\n");
+      return ((subclass(DisplayDriver))class(LFBDisplayDriver)).AllocateBitmap(displaySystem, bitmap, width, height, stride, format, allocatePalette);
+   }
+
+   void ::FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::FreeBitmap [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).FreeBitmap(displaySystem, bitmap);
+   }
+
+
+   // Lock
+
+   bool ::LockSystem(DisplaySystem displaySystem)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::LockSystem [STUB!]\n");
+      return false;
+   }
+
+   void ::UnlockSystem(DisplaySystem displaySystem)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::UnlockSystem [STUB!]\n");
+   }
+
+   bool ::Lock(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::Lock [STUB!]\n");
+      return false;
+   }
+
+   void ::Unlock(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::Unlock [STUB!]\n");
+   }
+
+
+   // Get/release a surface
+
+   bool ::GetSurface(Display display, Surface surface, int x, int y, Box clip)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::GetSurface [STUB!]\n");
+      return false;
+   }
+
+   bool ::GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::GetBitmapSurface [STUB!]\n");
+      return ((subclass(DisplayDriver))class(LFBDisplayDriver)).GetBitmapSurface(displaySystem, surface, bitmap, x, y, clip);
+   }
+
+   void ::ReleaseSurface(Display display, Surface surface)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::ReleaseSurface [STUB!]\n");
+   }
+
+
+   // Clip a surface
+
+   void ::Clip(Display display, Surface surface, Box clip)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::Clip [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Clip(display, surface, clip);
+   }
+
+
+   // Grab from the screen
+
+   bool ::GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::GrabScreen [STUB!]\n");
+      return false;
+   }
+
+
+   // Converts a bitmap format
+
+   bool ::ConvertBitmap(DisplaySystem displaySystem, Bitmap src, PixelFormat format, ColorAlpha * palette)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::ConvertBitmap [STUB!]\n");
+      return ((subclass(DisplayDriver))class(LFBDisplayDriver)).ConvertBitmap(displaySystem, src, format, palette);
+   }
+
+
+   // Converts an LFB bitmap into an offscreen bitmap for this device
+
+   bool ::MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::MakeDDBitmap [STUB!]\n");
+      return ((subclass(DisplayDriver))class(LFBDisplayDriver)).MakeDDBitmap(displaySystem, bitmap, mipMaps);
+   }
+
+
+   // Font loading
+
+   Font ::LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::LoadFont [STUB!]\n");
+      Font font = (Font)((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
+      return font;
+   }
+
+   void ::UnloadFont(DisplaySystem displaySystem, Font font)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::UnloadFont [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
+   }
+
+
+   // 2D Drawing
+
+   void ::SetForeground(Display display, Surface surface, ColorAlpha color)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::SetForeground [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).SetForeground(display, surface, color);
+   }
+
+   void ::SetBackground(Display display, Surface surface, ColorAlpha color)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::SetBackground [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).SetBackground(display, surface, color);
+   }
+
+   void ::SetBlitTint(Display display, Surface surface, ColorAlpha tint)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SetBlitTint [STUB!]\n");
+   }
+
+   void ::LineStipple(Display display, Surface surface, uint stipple)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::LineStipple [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).LineStipple(display, surface, stipple);
+   }
+
+   ColorAlpha ::GetPixel(Display display, Surface surface, int x, int y)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::GetPixel [STUB!]\n");
+      return 0;
+   }
+
+   void ::PutPixel(Display display, Surface surface, int x, int y)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::PutPixel [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).PutPixel(display, surface, x,y);
+   }
+
+   void ::DrawLine(Display display, Surface surface, int x1, int y1, int x2, int y2)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::DrawLine [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).DrawLine(display, surface, x1,y1,x2,y2);
+   }
+
+   void ::Rectangle(Display display, Surface surface, int x1, int y1, int x2, int y2)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::Rectangle [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Rectangle(display, surface, x1,y1,x2,y2);
+   }
+
+   void ::Area(Display display, Surface surface, int x1, int y1, int x2, int y2)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::Area [STUB!]\n");
+   }
+
+   void ::Clear(Display display, Surface surface, ClearType type)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::Clear [STUB!]\n");
+   }
+
+   void ::Blit(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::Blit [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Blit(display, surface, src, dx, dy, sx, sy, w, h);
+   }
+
+   void ::Stretch(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::Stretch [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Stretch(display, surface, src, dx, dy, sx, sy, w, h, sw, sh);
+   }
+
+   void ::Filter(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::Filter [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Filter(display, surface, src, dx, dy, sx, sy, w, h, sw, sh);
+   }
+
+   void ::BlitDI(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::BlitDI [STUB!]\n");
+      // Using Blit()
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Blit(display, surface, src, dx, dy, sx, sy, w, h);
+   }
+
+   void ::StretchDI(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::StretchDI [STUB!]\n");
+      // Using Stretch()
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Stretch(display, surface, src, dx, dy, sx, sy, w, h, sw, sh);
+   }
+
+   void ::FilterDI(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::FilterDI [STUB!]\n");
+      // Using Filter()
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).Filter(display, surface, src, dx, dy, sx, sy, w, h, sw, sh);
+   }
+
+   void ::TextFont(Display display, Surface surface, Font font)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::TextFont [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
+   }
+
+   void ::TextOpacity(Display display, Surface surface, bool opaque)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::TextOpacity [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextOpacity(display, surface, opaque);
+   }
+
+   void ::WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::WriteText [STUB!]\n");
+      if(surface.textOpacity)
+      {
+         int w, h;
+         ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
+         Area(display, surface, x, y, x+w-1, y+h-1);
+      }
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x,y, text, len);
+   }
+
+   void ::TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::TextExtent [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextExtent(display, surface, text, len, width, height);
+   }
+
+   void ::FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
+   {
+      //sflnprintf("class(TemplateDisplayDriver) ::FontExtent [STUB!]\n");
+      ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
+   }
+
+   void ::DrawingChar(Display display, Surface surface, char character)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::DrawingChar [STUB!]\n");
+   }
+
+   void ::NextPage(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::NextPage [STUB!]\n");
+   }
+
+   // 3D Graphics
+
+#if !defined(ECERE_VANILLA) && !defined(ECERE_NO3D)
+   void ::SetRenderState(Display display, RenderState state, uint value)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SetRenderState [STUB!]\n");
+   }
+
+   void ::SetLight(Display display, int id, Light light)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SetLight [STUB!]\n");
+   }
+
+   void ::SetCamera(Display display, Surface surface, Camera camera)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SetCamera [STUB!]\n");
+   }
+
+   bool ::AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::AllocateMesh [STUB!]\n");
+      return false;
+   }
+
+   void ::FreeMesh(DisplaySystem displaySystem, Mesh mesh)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::FreeMesh [STUB!]\n");
+   }
+
+   bool ::LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::LockMesh [STUB!]\n");
+      return false;
+   }
+
+   void ::UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::UnlockMesh [STUB!]\n");
+   }
+
+   void * ::AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::AllocateIndices [STUB!]\n");
+      return null;
+   }
+
+   void ::FreeIndices(DisplaySystem displaySystem, void * indices)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::FreeIndices [STUB!]\n");
+   }
+
+   uint16 * ::LockIndices(DisplaySystem displaySystem, void * indices)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::LockIndices [STUB!]\n");
+      return null;
+   }
+
+   void ::UnlockIndices(DisplaySystem displaySystem, void * indices, bool indices32bit, int nIndices)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::UnlockIndices [STUB!]\n");
+   }
+
+   void ::SelectMesh(Display display, Mesh mesh)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SelectMesh [STUB!]\n");
+   }
+
+   void ::ApplyMaterial(Display display, Material material, Mesh mesh)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::ApplyMaterial [STUB!]\n");
+   }
+
+   void ::DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::DrawPrimitives [STUB!]\n");
+   }
+
+   void ::PushMatrix(Display display)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::PushMatrix [STUB!]\n");
+   }
+
+   void ::PopMatrix(Display display, bool setMatrix)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::PopMatrix [STUB!]\n");
+   }
+
+   void ::SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
+   {
+      sflnprintf("class(TemplateDisplayDriver) ::SetTransform [STUB!]\n");
+   }
+#endif
+
+}
+
+#endif // !defined(NO_TEMPLATE_DRIVER)

diff --git a/ecere/src/gui/drivers/TemplateInterface.ec b/ecere/src/gui/drivers/TemplateInterface.ec
new file mode 100644 (file)
index 0000000..71523ce
--- /dev/null
+++ b/ecere/src/gui/drivers/TemplateInterface.ec
@@ -0,0 +1,273 @@
+namespace gui::drivers;
+
+#ifdef BUILDING_ECERE_COM
+import "Window"
+import "Interface"
+#else
+#ifdef ECERE_STATIC
+public import static "ecere"
+#else
+public import "ecere"
+#endif
+#endif
+
+#if !defined(NO_TEMPLATE_DRIVER)
+
+#include <stdio.h>
+
+// source file line number printf (sflnprintf)
+#define sflnprintf(format,...) printf("%s:% 5d: " format, __FILE__, __LINE__, ##__VA_ARGS__)
+
+class TemplateInterface : Interface
+{
+   class_property(name) = "Template";
+
+
+   // --- User Interface System ---
+
+   bool ::Initialize()
+   {
+      sflnprintf("class(TemplateInterface) ::Initialize [STUB!]\n");
+      return false;
+   }
+
+   void ::Terminate()
+   {
+      sflnprintf("class(TemplateInterface) ::Terminate [STUB!]\n");
+   }
+
+   bool ::ProcessInput(bool processAll)
+   {
+      sflnprintf("class(TemplateInterface) ::ProcessInput [STUB!]\n");
+      return false;
+   }
+
+   void ::Wait()
+   {
+      sflnprintf("class(TemplateInterface) ::Wait [STUB!]\n");
+   }
+
+   void ::Lock(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::Lock [STUB!]\n");
+   }
+
+   void ::Unlock(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::Unlock [STUB!]\n");
+   }
+
+   void ::SetTimerResolution(uint hertz)
+   {
+      sflnprintf("class(TemplateInterface) ::SetTimerResolution [STUB!] Implement high resolution timer here\n");
+   }
+
+   const char ** ::GraphicsDrivers(int * numDrivers)
+   {
+      //sflnprintf("class(TemplateInterface) ::GraphicsDrivers [STUB!]\n");
+      static const char *graphicsDrivers[] = { "Template" };
+      *numDrivers = sizeof(graphicsDrivers) / sizeof(char *);
+      return (const char **)graphicsDrivers;
+   }
+
+   void ::EnsureFullScreen(bool * fullScreen)
+   {
+      sflnprintf("class(TemplateInterface) ::EnsureFullScreen [STUB!]\n");
+   }
+
+   void ::GetCurrentMode(bool * fullScreen, Resolution * resolution, PixelFormat * colorDepth, int * refreshRate)
+   {
+      sflnprintf("class(TemplateInterface) ::GetCurrentMode [STUB!]\n");
+   }
+
+   bool ::ScreenMode(bool fullScreen, Resolution resolution, PixelFormat colorDepth, int refreshRate, bool * textMode)
+   {
+      sflnprintf("class(TemplateInterface) ::ScreenMode [STUB!]\n");
+      return false;
+   }
+
+
+   // --- Window Creation ---
+
+   void * ::CreateRootWindow(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::CreateRootWindow [STUB!]\n");
+      return null;
+   }
+
+   void ::DestroyRootWindow(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::DestroyRootWindow [STUB!]\n");
+   }
+
+
+   // --- Window manipulation ---
+
+   void ::SetRootWindowCaption(Window window, const char * name)
+   {
+      sflnprintf("class(TemplateInterface) ::SetRootWindowCaption [STUB!]\n");
+   }
+
+   void ::PositionRootWindow(Window window, int x, int y, int w, int h, bool move, bool resize)
+   {
+      sflnprintf("class(TemplateInterface) ::Stub [STUB!]\n");
+   }
+
+   void ::OffsetWindow(Window window, int * x, int * y)
+   {
+      sflnprintf("class(TemplateInterface) ::OffsetWindow [STUB!]\n");
+   }
+
+   void ::UpdateRootWindow(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::UpdateRootWindow [STUB!]\n");
+   }
+
+   void ::SetRootWindowState(Window window, WindowState state, bool visible)
+   {
+      sflnprintf("class(TemplateInterface) ::SetRootWindowState [STUB!]\n");
+   }
+
+   void ::ActivateRootWindow(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::ActivateRootWindow [STUB!]\n");
+   }
+
+   void ::OrderRootWindow(Window window, bool topMost)
+   {
+      sflnprintf("class(TemplateInterface) ::OrderRootWindow [STUB!]\n");
+   }
+
+   void ::SetRootWindowColor(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::SetRootWindowColor [STUB!]\n");
+   }
+
+   void ::FlashRootWindow(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::FlashRootWindow [STUB!]\n");
+   }
+
+
+   // --- Mouse-based window movement ---
+
+   void ::StartMoving(Window window, int x, int y, bool fromKeyBoard)
+   {
+      sflnprintf("class(TemplateInterface) ::StartMoving [STUB!]\n");
+   }
+
+   void ::StopMoving(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::StopMoving [STUB!]\n");
+   }
+
+
+   // --- Mouse manipulation ---
+
+   void ::GetMousePosition(int *x, int *y)
+   {
+      sflnprintf("class(TemplateInterface) ::GetMousePosition [STUB!]\n");
+   }
+
+   void ::SetMousePosition(int x, int y)
+   {
+      sflnprintf("class(TemplateInterface) ::SetMousePosition [STUB!]\n");
+   }
+
+   void ::SetMouseRange(Window window, Box box)
+   {
+      sflnprintf("class(TemplateInterface) ::SetMouseRange [STUB!]\n");
+   }
+
+   void ::SetMouseCapture(Window window)
+   {
+      sflnprintf("class(TemplateInterface) ::SetMouseCapture [STUB!]\n");
+   }
+
+
+   // --- Mouse cursor ---
+
+   void ::SetMouseCursor(Window window, SystemCursor cursor)
+   {
+      sflnprintf("class(TemplateInterface) ::SetMouseCursor [STUB!]\n");
+   }
+
+
+   // --- Caret manipulation ---
+
+   void ::SetCaret(int caretX, int caretY, int size)
+   {
+      sflnprintf("class(TemplateInterface) ::SetCaret [STUB!]\n");
+   }
+
+
+   // --- Clipboard manipulation ---
+
+   void ::ClearClipboard()
+   {
+      sflnprintf("class(TemplateInterface) ::ClearClipboard [STUB!]\n");
+   }
+
+   bool ::AllocateClipboard(ClipBoard clipBoard, uint size)
+   {
+      sflnprintf("class(TemplateInterface) ::AllocateClipboard [STUB!]\n");
+      return false;
+   }
+
+   bool ::SaveClipboard(ClipBoard clipBoard)
+   {
+      sflnprintf("class(TemplateInterface) ::SaveClipboard [STUB!]\n");
+      return false;
+   }
+
+   bool ::LoadClipboard(ClipBoard clipBoard)
+   {
+      sflnprintf("class(TemplateInterface) ::LoadClipboard [STUB!]\n");
+      return false;
+   }
+
+   void ::UnloadClipboard(ClipBoard clipBoard)
+   {
+      sflnprintf("class(TemplateInterface) ::UnloadClipboard [STUB!]\n");
+   }
+
+
+   // --- State based input ---
+
+   bool ::AcquireInput(Window window, bool state)
+   {
+      sflnprintf("class(TemplateInterface) ::AcquireInput [STUB!]\n");
+      return false;
+   }
+
+   bool ::GetMouseState(MouseButtons * buttons, int * x, int * y)
+   {
+      sflnprintf("class(TemplateInterface) ::GetMouseState [STUB!]\n");
+      return false;
+   }
+
+   bool ::GetJoystickState(int device, Joystick joystick)
+   {
+      sflnprintf("class(TemplateInterface) ::GetJoystickState [STUB!]\n");
+      return false;
+   }
+
+   bool ::GetKeyState(Key key)
+   {
+      sflnprintf("class(TemplateInterface) ::GetKeyState [STUB!]\n");
+      return false;
+   }
+
+   bool ::SetIcon(Window window, BitmapResource icon)
+   {
+      sflnprintf("class(TemplateInterface) ::SetIcon [STUB!]\n");
+      return false;
+   }
+
+   void ::GetScreenArea(Window window, Box box)
+   {
+      sflnprintf("class(TemplateInterface) ::GetScreenArea [STUB!]\n");
+   }
+}
+
+#endif // !defined(NO_TEMPLATE_DRIVER)