Public API Reference

csplugincommon/canvas/graph2d.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2001 by Jorrit Tyberghein
    Written by Andrew Zabolotny <[email protected]>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSPLUGINCOMMON_CANVAS_GRAPH2D_H__
#define __CS_CSPLUGINCOMMON_CANVAS_GRAPH2D_H__

#include "csextern.h"

#include "csutil/cfgacc.h"
#include "csutil/scf.h"
#include "csutil/scf_implementation.h"
#include "csutil/weakref.h"

#include "iutil/comp.h"
#include "iutil/dbghelp.h"
#include "iutil/eventh.h"
#include "iutil/plugin.h"
#include "iutil/pluginconfig.h"
#include "iutil/string.h"
#include "ivideo/fontserv.h"
#include "ivideo/graph2d.h"
#include "ivideo/natwin.h"

struct iObjectRegistry;
struct iPluginManager;

class csFontCache;

#include "csutil/win32/msvc_deprecated_warn_off.h"

class CS_CRYSTALSPACE_EXPORT csGraphics2D : 
  public scfImplementation7<csGraphics2D, 
    iGraphics2D, iComponent, iNativeWindow, iNativeWindowManager,
    iPluginConfig, iDebugHelper, iEventHandler>
{
public:
  csConfigAccess config;

  int ClipX1, ClipX2, ClipY1, ClipY2;

  csPixelFormat pfmt;

  unsigned char *Memory;

  bool is_open;

  int *LineAddress;

  iObjectRegistry* object_reg;
  csWeakRef<iPluginManager> plugin_mgr;

  csRef<iOffscreenCanvasCallback> ofscb;

  csWeakRef<iFontServer> FontServer;
  csFontCache* fontCache;

  csString win_title;

  int Width, Height, Depth;

  int vpWidth, vpHeight;
  bool vpSet;

  int DisplayNumber;
  bool FullScreen;
  bool AllowResizing;
  csRGBpixel *Palette;
  bool PaletteAlloc[256];
  int FrameBufferLocked;
  virtual void ChangeDepth (int d);
  virtual const char *GetName() const;

protected:
  int refreshRate;
  bool vsync;

  void CreateDefaultFontCache ();

  csString name;
  csRef<iEventHandler> weakEventHandler;

private:
  int FindRGBPalette (int r, int g, int b);
  bool Initialize (iObjectRegistry* r, int width, int height,
        int depth, void* memory, iOffscreenCanvasCallback* ofscb);

public:
  csGraphics2D (iBase*);

  virtual ~csGraphics2D ();

  virtual bool Initialize (iObjectRegistry*);
  virtual bool HandleEvent (iEvent&);

  virtual bool Open ();
  virtual void Close ();

  virtual void SetClipRect (int xmin, int ymin, int xmax, int ymax);
  virtual void GetClipRect (int &xmin, int &ymin, int &xmax, int &ymax);

  virtual bool BeginDraw ();
  virtual void FinishDraw ();

  virtual void Print (csRect const* /*area*/ = 0) { }

  virtual int GetPage ();
  virtual bool DoubleBuffer (bool Enable);
  virtual bool GetDoubleBufferState ();

  virtual void Clear (int color);
  virtual void ClearAll (int color);


  void (*_DrawPixel) (csGraphics2D *This, int x, int y, int color);
  virtual void DrawPixel (int x, int y, int color)
  { _DrawPixel (this, x, y, color); }
  virtual void DrawPixels (csPixelCoord const* pixels, int num_pixels,
    int color);
  virtual void Blit (int x, int y, int width, int height,
        unsigned char const* data);

  virtual void DrawLine (float x1, float y1, float x2, float y2, int color);
  virtual void DrawBox (int x, int y, int w, int h, int color);
  virtual void SetRGB (int i, int r, int g, int b);
  virtual int FindRGB (int r, int g, int b, int a = 255)
  {
    if (r < 0) r = 0; else if (r > 255) r = 255;
    if (g < 0) g = 0; else if (g > 255) g = 255;
    if (b < 0) b = 0; else if (b > 255) b = 255;
    if (a < 0) a = 0; else if (a > 255) a = 255;
    if (Depth == 8)
      return FindRGBPalette (r, g, b);
    return
      ((r >> (8 - pfmt.RedBits))   << pfmt.RedShift) |
      ((g >> (8 - pfmt.GreenBits)) << pfmt.GreenShift) |
      ((b >> (8 - pfmt.BlueBits))  << pfmt.BlueShift) |
      ((255 - a) << 24);
    /* Alpha is "inverted" so '-1' can be decomposed to a 
       transparent color. (But alpha not be inverted, '-1'
       would be "opaque white". However, -1 is the color
       index for "transparent text background". */
  }
  virtual void GetRGB (int color, int& r, int& g, int& b);
  virtual void GetRGB (int color, int& r, int& g, int& b, int& a);

  virtual void Write (iFont *font , int x, int y, int fg, int bg,
    const char *text, uint flags = 0);
  virtual void Write (iFont *font , int x, int y, int fg, int bg,
    const wchar_t* text, uint flags = 0);
  virtual void WriteBaseline (iFont *font , int x, int y, int fg, int bg,
    const char *text);

  unsigned char* (*_GetPixelAt) (csGraphics2D *This, int x, int y);
  virtual unsigned char *GetPixelAt (int x, int y)
  { return _GetPixelAt (this, x, y); }

  virtual int GetPalEntryCount ()
  { return pfmt.PalEntries; }

  virtual int GetPixelBytes ()
  { return pfmt.PixelBytes; }

  virtual csPixelFormat const* GetPixelFormat ()
  { return &pfmt; }

  virtual csImageArea *SaveArea (int x, int y, int w, int h);
  virtual void RestoreArea (csImageArea *Area, bool Free = true);
  virtual void FreeArea (csImageArea *Area);

  virtual bool SetGamma (float /*gamma*/) { return false; }
  virtual float GetGamma () const { return 1.0; }

  virtual csPtr<iGraphics2D> CreateOffscreenCanvas (
        void* memory, int width, int height, int depth,
        iOffscreenCanvasCallback* ofscb);

private:
  bool CLIPt (float denom, float num, float& tE, float& tL);
public:

  virtual bool ClipLine (float &x1, float &y1, float &x2, float &y2,
    int xmin, int ymin, int xmax, int ymax);

  virtual iFontServer *GetFontServer ()
  { return FontServer; }

  virtual int GetWidth ()
  { return vpSet ? vpWidth : Width; }
  virtual int GetHeight ()
  { return vpSet ? vpHeight : Height; }

  virtual csRGBpixel *GetPalette ()
  { return pfmt.PalEntries ? Palette : 0; }

  virtual void GetPixel (int x, int y, uint8 &oR, uint8 &oG, uint8 &oB);
  virtual void GetPixel (int x, int y, uint8 &oR, uint8 &oG, uint8 &oB, uint8 &oA);

  virtual bool PerformExtension (char const* command, ...);

  virtual bool PerformExtensionV (char const* command, va_list);

  virtual csPtr<iImage> ScreenShot ();

  virtual void AllowResize (bool /*iAllow*/) { };

  virtual bool Resize (int w, int h);

  virtual iNativeWindow* GetNativeWindow ();

  virtual bool GetFullScreen ()
  { return FullScreen; }

  virtual void SetFullScreen (bool b);

  virtual bool SetMousePosition (int x, int y);

  virtual bool SetMouseCursor (csMouseCursorID iShape);

  virtual bool SetMouseCursor (iImage *image, const csRGBcolor* keycolor = 0, 
                               int hotspot_x = 0, int hotspot_y = 0,
                               csRGBcolor fg = csRGBcolor(255,255,255),
                               csRGBcolor bg = csRGBcolor(0,0,0));

  CS_EVENTHANDLER_NAMES("crystalspace.graphics2d.common")
  CS_EVENTHANDLER_NIL_CONSTRAINTS

protected:

  static void DrawPixel8 (csGraphics2D *This, int x, int y, int color);
  static unsigned char *GetPixelAt8 (csGraphics2D *This, int x, int y);

  static void DrawPixel16 (csGraphics2D *This, int x, int y, int color);
  static unsigned char *GetPixelAt16 (csGraphics2D *This, int x, int y);

  static void DrawPixel32 (csGraphics2D *This, int x, int y, int color);
  static unsigned char *GetPixelAt32 (csGraphics2D *This, int x, int y);

  // Virtual Alert function so it can be overridden by subclasses
  // of csGraphics2D.
  virtual void AlertV (int type, const char* title, const char* okMsg,
    const char* msg, va_list args);
  virtual void Alert (int type, const char* title, const char* okMsg,
      const char* msg, ...);
  virtual void AlertV (int type, const wchar_t* title, const wchar_t* okMsg,
    const wchar_t* msg, va_list args);
  virtual void Alert (int type, const wchar_t* title, const wchar_t* okMsg,
      const wchar_t* msg, ...);
  // Virtual SetTitle function so it can be overridden by subclasses
  // of csGraphics2D.
  virtual void SetTitle (const char* title);
  virtual void SetTitle (const wchar_t* title)
  { SetTitle (csString (title)); }
  virtual bool GetOptionDescription (int idx, csOptionDescription*);
  virtual bool SetOption (int id, csVariant* value);
  virtual bool GetOption (int id, csVariant* value);
  virtual bool DebugCommand (const char* cmd);
  virtual int GetSupportedTests () const { return 0; }
  virtual csPtr<iString> UnitTest () { return 0; }
  virtual csPtr<iString> StateTest ()  { return 0; }
  virtual csTicks Benchmark (int /*num_iterations*/) { return 0; }
  virtual csPtr<iString> Dump ()  { return 0; }
  virtual void Dump (iGraphics3D* /*g3d*/)  { }
};

#include "csutil/win32/msvc_deprecated_warn_on.h"

#endif // __CS_CSPLUGINCOMMON_CANVAS_GRAPH2D_H__

---