From bff0f71162a00355c0c35debd039cfd2d54162a1 Mon Sep 17 00:00:00 2001 From: Rejean Loyer Date: Mon, 18 Aug 2014 12:36:52 -0400 Subject: [PATCH] ecere: gfx/gui: add dummy driver named Template to serve as basis for implementing new drivers. --- ecere/ecere.epj | 4 +- ecere/src/gfx/drivers/TemplateDisplayDriver.ec | 459 +++++++++++++++++++++++++ ecere/src/gui/drivers/TemplateInterface.ec | 273 +++++++++++++++ 3 files changed, 735 insertions(+), 1 deletion(-) create mode 100644 ecere/src/gfx/drivers/TemplateDisplayDriver.ec create mode 100644 ecere/src/gui/drivers/TemplateInterface.ec diff --git a/ecere/ecere.epj b/ecere/ecere.epj index 2432b50..eb7276a 100644 --- 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 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 + +// 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 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 + +// 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) -- 1.8.3.1