---

displaycard.h

Go to the documentation of this file.

/*
        $Id: displaycard.h,v 1.2 2001/03/15 12:14:46 mbn Exp $

        ------------------------------------------------------------------------
        ClanLib, the platform independent game SDK.

        This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
        version 2. See COPYING for details.

        For a total list of contributers see CREDITS.

        ------------------------------------------------------------------------
*/


#ifndef header_displaycard
#define header_displaycard

#include <list>
#include <string>

class CL_VidMode;
class CL_Palette;
class CL_Target;
class CL_Rect;

#include "cliprect.h"
#include "../../signals.h"

class CL_InputSourceProvider;
class CL_DisplayCard
//: The display card class.
// <p>This class represents a display card in ClanLib. It is mainly used to
// set the videomode, flip the display and do simple graphics operations
// such as filled rectangles or drawing lines.</p>
//
// <p>If you're always only using one display card at the time, you may want
// to consider using the static functions in CL_Display instead. They do
// exactly the same, but operates on a selected display card instead
// (default the primary card). This saves you from passing around a pointer
// to the displaycard.</p>
{
public:
        virtual const std::list<CL_VidMode*> &get_videomodes()=0;
//: Get list of videomodes available on this card.

        virtual std::string get_name()=0;
//: Get name of the card.
        
        virtual int get_total_memory()=0;
//: Get videomemory available.
        
        virtual int get_card_no()=0;
//: Get card number.

        virtual ~CL_DisplayCard() { ; }

        virtual void flip_display(bool sync=false)=0;
//: Flips the front and backbuffer. Everything is normally drawn to the 
//: backbuffer, and flip_display() needs to be called before it can be seen 
//: onto the screen.

        virtual void put_display(const class CL_Rect &rect)=0;
//: Copies the specified area of the backbuffer to the front buffer. This is
//: in particular useful if you only want to update a limited region, and not
//: do a full-blown flipping.

        virtual void sync_buffers()=0;
//: Copies the contents of the frontbuffer to all other buffers (usually just
//: the backbuffer). This ensures that all buffers contain the same image.

        virtual void clear_display(float red=0, float green=0, float blue=0, float alpha=1)=0;
//: Clears backbuffer with the specified color.

        virtual void set_palette(CL_Palette *palette)=0;
//: Set system palette on this card.
//: <br>
//: If the display card is in a non-palettelized mode, this will be the palette 
//: used when surfaceproviders doesn't specify a palette themself.
        
        virtual CL_Palette *get_palette()=0;
//: Return the current system palette on this card.

        virtual void set_videomode(CL_VidMode *mode);
//: Change the display card's video mode.

        virtual void set_videomode(
                int width,
                int height,
                int bpp,
                bool fullscreen = true,
                bool allow_resize = false,
                bool video_memory = true)=0;
//: Change the display card's video mode.

        virtual bool is_initialized()=0;
//: Returns true if the display card is in a video mode.

        virtual CL_Target* get_target()=0;
//: Return either NULL or the Target that is blitted to (aka Framebuffer)
//:!retval: NULL if Framebuffer access is not possible, CL_Target if it is

        virtual int get_width()=0;
//: Returns the width of the current video mode.

        virtual int get_height()=0;
//: Returns the height of the current video mode.

        virtual int get_bpp()=0;
//: Returns the depth of the current video mode.

        virtual void push_clip_rect()=0;
//: Pushes the current clipping rectangle onto the cliprect stack.

        virtual void push_clip_rect(const CL_ClipRect &rect)=0;
//: Pushes the current clipping rectangle onto the cliprect stack. It then clips 
//: the passed rectangle 'rect' with the current one, and uses the result as the 
//: new clipping rect.
 
        virtual CL_ClipRect get_clip_rect()=0;
//: Returns the current clipping rectangle.
 
        virtual void set_clip_rect(const CL_ClipRect &rect)=0;
//: Sets the current clipping rectangle. This is an absolute set, so it doesn't
//: get clipped with the previous one.

        virtual void pop_clip_rect()=0;
//: Pop the clipping rectangle last pushed onto the stack.

        virtual void push_translate_offset()=0;
//: Pushes the current translation rectangle onto the cliprect stack.

        virtual void push_translate_offset(int x, int y)=0;
//: Push translation offset onto translation stack. This offset will
//: affect any subsequent display operations on the displaycard, by
//: translating the position of the display operation with the offset.
//: The offset will be offset by any previous offsets pushed onto the stack,
//: eg. it inherits the previous offset.

        virtual int  get_translate_offset_x() =0;
//: Returns the current effective x-axis translation offset.

        virtual int  get_translate_offset_y() =0;
//: Returns the current effective y-axis translation offset.

        virtual void set_translate_offset(int x, int y)=0;
//: Sets the translation offset as a new absolute translation offset.
//: The new offset will disregard any previous offset's, but will not
//: empty the translation stack. The new translation offset will affect
//: any subsequent display operations on the displaycard, by
//: translating the position of the display operation with the offset

        virtual void pop_translate_offset()=0;
//: Pops the last pushed translation offset from the translation offset
//: stack. If the stack is empty, nothing will happen, and if the last
//: translation offset is popped, the translation offset will be set to 0,0

        virtual void fill_rect(int x1, int y1, int x2, int y2, float r, float g, float b, float a)=0;
//: Draw a filled rectangle from ('x1', 'y1') to ('x2', 'y2') using the color
//: ('r', 'g', 'b', 'a').

        virtual void draw_rect(int x1, int y1, int x2, int y2, float r, float g, float b, float a)=0;
//: Draw a rectangle from ('x1', 'y1') to ('x2', 'y2') using the color
//: ('r', 'g', 'b', 'a').

        virtual void draw_line(int x1, int y1, int x2, int y2, float r, float g, float b, float a)=0;
//: Draw a line from ('x1', 'y1') to ('x2', 'y2') using the color
//: ('r', 'g', 'b', 'a').
        
        virtual CL_Signal_v2<int, int> &get_sig_resize()=0;
//: Returns the resize signal for the display card.
// You can use this signal to listen for window resize events.
// The parameters passed by the signal are the new width and height of the window.

        virtual CL_Signal_v1<const CL_Rect &> &get_sig_paint()=0;
//: Returns the paint signal for the display card.
// Use this signal to listen for invalidated screen areas that need to be repainted.
// The parameter passed by the signal is the area that need a repaint.
};

#endif

---