/*

https://github.com/peterix/dfhack

Copyright (c) 2009-2012 Petr Mrázek (peterix@gmail.com)

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any

damages arising from the use of this software.

Permission is granted to anyone to use this software for any

purpose, including commercial applications, and to alter it and

redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must

not claim that you wrote the original software. If you use this

software in a product, an acknowledgment in the product documentation

would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and

must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source

distribution.

*/

#pragma once

#include "Export.h"

#include <cstddef>

namespace DFHack

{

namespace Windows

{

/*

* DF window stuffs

*/

enum df_color

{

black,

blue,

green,

cyan,

red,

magenta,

brown,

lgray,

dgray,

lblue,

lgreen,

lcyan,

lred,

lmagenta,

yellow,

white

// maybe add transparency?

};

// The tile format DF uses internally

struct df_screentile

{

uint8_t symbol;

uint8_t foreground; ///< df_color

uint8_t background; ///< df_color

uint8_t bright;

};

// our silly painter things and window things follow.

class df_window;

struct df_tilebuf

{

df_screentile * data;

unsigned int width;

unsigned int height;

};

DFHACK_EXPORT df_screentile *getScreenBuffer();

class DFHACK_EXPORT painter

{

friend class df_window;

public:

df_screentile* get(unsigned int x, unsigned int y)

{

if(x >= width || y >= height)

return 0;

return &buffer[x*height + y];

};

bool set(unsigned int x, unsigned int y, df_screentile tile )

{

if(x >= width || y >= height)

return false;

buffer[x*height + y] = tile;

return true;

}

df_color foreground (df_color change = (df_color) -1)

{

if(change != -1)

current_foreground = change;

return current_foreground;

}

df_color background (df_color change = (df_color) -1)

{

if(change != -1)

current_background = change;

return current_background;

}

void bright (bool change)

{

current_bright = change;

}

bool bright ()

{

return current_bright;

}

void printStr(std::string & str, bool wrap = false)

{

for ( auto iter = str.begin(); iter != str.end(); iter++)

{

auto elem = *iter;

if(cursor_y >= (int)height)

break;

if(wrap)

{

if(cursor_x >= (int)width)

cursor_x = wrap_column;

}

df_screentile & tile = buffer[cursor_x * height + cursor_y];

tile.symbol = elem;

tile.foreground = current_foreground;

tile.background = current_background;

tile.bright = current_bright;

cursor_x++;

}

}

void set_wrap (int new_column)

{

wrap_column = new_column;

}

void gotoxy(unsigned int x, unsigned int y)

{

cursor_x = x;

cursor_y = y;

}

void reset()

{

cursor_x = 0;

cursor_y = 0;

current_background = black;

current_foreground = white;

current_bright = false;

wrap_column = 0;

}

private:

painter (df_window * orig, df_screentile * buf, unsigned int width, unsigned int height)

{

origin = orig;

this->width = width;

this->height = height;

this->buffer = buf;

reset();

}

df_window* origin;

unsigned int width;

unsigned int height;

df_screentile* buffer;

// current paint cursor position

int cursor_x;

int cursor_y;

int wrap_column;

// current foreground color

df_color current_foreground;

// current background color

df_color current_background;

// make bright?

bool current_bright;

};

class DFHACK_EXPORT df_window

{

friend class painter;

public:

df_window(int x, int y, unsigned int width, unsigned int height);

virtual ~df_window();

virtual bool move (int left_, int top_, unsigned int width_, unsigned int height_) = 0;

virtual void paint () = 0;

virtual painter * lock();

bool unlock (painter * painter);

virtual bool addChild(df_window *);

virtual df_tilebuf getBuffer() = 0;

public:

df_screentile* buffer;

unsigned int width;

unsigned int height;

protected:

df_window * parent;

std::vector <df_window *> children;

int left;

int top;

// FIXME: FAKE

bool locked;

painter * current_painter;

};

class DFHACK_EXPORT top_level_window : public df_window

{

public:

top_level_window();

virtual bool move (int left_, int top_, unsigned int width_, unsigned int height_);

virtual void paint ();

virtual painter * lock();

virtual df_tilebuf getBuffer();

};

class DFHACK_EXPORT buffered_window : public df_window

{

public:

buffered_window(int x, int y, unsigned int width, unsigned int height):df_window(x,y,width, height)

{

buffer = new df_screentile[width*height];

};

virtual ~buffered_window()

{

delete buffer;

}

virtual void blit_to_parent ()

{

df_tilebuf par = parent->getBuffer();

for(unsigned xi = 0; xi < width; xi++)

{

for(unsigned yi = 0; yi < height; yi++)

{

unsigned parx = left + xi;

unsigned pary = top + yi;

if(pary >= par.height) continue;

if(parx >= par.width) continue;

par.data[parx * par.height + pary] = buffer[xi * height + yi];

}

}

}

virtual df_tilebuf getBuffer()

{

df_tilebuf buf;

buf.data = buffer;

buf.width = width;

buf.height = height;

return buf;

};

};

class DFHACK_EXPORT dfhack_dummy : public buffered_window

{

public:

dfhack_dummy(int x, int y):buffered_window(x,y,6,1){};

virtual bool move (int left_, int top_, unsigned int width_, unsigned int height_)

{

top = top_;

left = left_;

return true;

}

virtual void paint ()

{

painter * p = lock();

p->bright(true);

p->background(black);

p->foreground(white);

std::string dfhack = "DFHack";

p->printStr(dfhack);

blit_to_parent();

}

};

}

}