Miroirs/eliot
1
0
Fork 0
mirror of git://git.savannah.nongnu.org/eliot.git synced 2025-01-18 10:26:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

- new gfxboard class drawing with tiles

Browse source
This commit is contained in:
Antoine Fraboulet 2005-12-26 15:02:26 +00:00
parent 094a920a4a
commit 1b4cdf5acf
5 changed files with 504 additions and 293 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
wxwin/auxframes.cc
View file

@ -122,9 +122,9 @@ void
BoardFrame::Refresh(refresh_t force)
{
if (force == REFRESH)
board->Refresh(BOARD_REFRESH);
board->Refresh(GfxBoard::BOARD_REFRESH);
else
board->Refresh(BOARD_FORCE_REFRESH);
board->Refresh(GfxBoard::BOARD_FORCE_REFRESH);
}
/****************************************************************/

40
wxwin/configdb.cc
View file

@ -1,13 +1,14 @@
/* Eliot */
/* Copyright (C) 1999 Antoine Fraboulet */
/* Antoine.Fraboulet@free.fr */
/* */
/* This program is free software; you can redistribute it and/or modify */
/* This file is part of Eliot. */
/* */
/* Eliot is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or */
/* (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* Eliot 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 General Public License for more details. */
@ -16,6 +17,13 @@
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
/**
* \file configdb.cc
* \brief Access to Eliot persistant configuration data
* \author Antoine Fraboulet
* \date 2002
*/
#include <iostream>
#include "ewx.h"
#include "configdb.h"
@ -456,7 +464,12 @@ wxFont ConfigDB::ChooseFont(wxFrame* frame,wxFont initfont)
void ConfigDB::setFontDefault()
{
wxFont fsys;
#ifdef WXWIN24
fsys = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
#else
fsys = wxSystemSettingsNative::GetFont(wxSYS_DEFAULT_GUI_FONT);
#endif
setFont(BOARDFONT ,fsys);
setFont(LISTFONT ,fsys);
@ -502,6 +515,10 @@ wxColour ConfigDB::ChooseColour(wxFrame* frame,wxColour initcolour)
#define BACKDEF wxColour(255,255,255)
#define LETTDEF wxColour( 0, 0, 0)
#define TSTLETTDEF wxColour( 0, 0, 0)
#define TILEDEF wxColour(0xff,0xeb,0xcd)
//#define TSTTILEDEF wxColour(0xff,0xe4,0xb5)
//#define TSTTILEDEF wxColour(0x46,0x82,0xb4)
#define TSTTILEDEF wxColour(0xbd,0xb7,0x7b)
void ConfigDB::setColourDefault()
{
@ -512,6 +529,8 @@ void ConfigDB::setColourDefault()
setColour(wxString(BCOLOURLX3),LX3DEF);
setColour(wxString(BCOLOURBACKGROUND),BACKDEF);
setColour(wxString(BCOLOURLETTERS),LETTDEF);
setColour(wxString(BTILEBACKGROUND),TILEDEF);
setColour(wxString(BTSTTILEBACKGROUND),TSTTILEDEF);
}
void
@ -767,6 +786,20 @@ bool ConfigDB::getRackChecking()
return Read(key,(bool)FALSE);
}
void ConfigDB::setDrawTile(bool val)
{
wxString key;
key = wxString(BDRAWBACKGROUND);
Write(key,val);
}
bool ConfigDB::getDrawTile()
{
wxString key;
key = wxString(BDRAWBACKGROUND);
return Read(key,(bool)TRUE);
}
////////////////////////////////////////////////////////
//
//
@ -787,4 +820,3 @@ ConfigDB::setFirstDefault()
Write(wxString(INIT),1L);
}

28
wxwin/configdb.h
View file

@ -1,13 +1,14 @@
/* Eliot */
/* Copyright (C) 1999 Antoine Fraboulet */
/* Antoine.Fraboulet@free.fr */
/* */
/* This program is free software; you can redistribute it and/or modify */
/* This file is part of Eliot. */
/* */
/* Eliot is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or */
/* (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* Eliot 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 General Public License for more details. */
@ -16,7 +17,12 @@
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
// -*-C++-*-
/**
* \file configdb.h
* \brief Access to Eliot persistant configuration data
* \author Antoine Fraboulet
* \date 2002
*/
#ifndef _CONFIGDB_H
#define _CONFIGDB_H
@ -41,6 +47,10 @@
#define BCOLOURTSTLETTERS wxT(BOARD"/TstLetters")
#define BOARDFONT wxT(BOARD"/Font")
#define BDRAWBACKGROUND wxT(BOARD"/DrawTile")
#define BTILEBACKGROUND wxT(BOARD"/TileBG")
#define BTSTTILEBACKGROUND wxT(BOARD"/TstTileBG")
#define LIST "List"
#define LISTFONT wxT(LIST"/Font")
@ -58,6 +68,8 @@
#define FRAMERACC wxT(FRAME"Racc")
#define FRAMEBENJ wxT(FRAME"Benj")
#define FRAMEBAG wxT(FRAME"Bag")
#define FRAMEGAME wxT(FRAME"Game")
#define FRAMERESULT wxT(FRAME"Result")
enum Justif { LEFT, CENTER, RIGHT };
@ -160,11 +172,15 @@ public:
void setFrameShow(wxString,int);
void setFrameDefault();
void setJokerPlus1(bool);
void setRackChecking(bool);
bool getJokerPlus1();
bool getRackChecking();
void setJokerPlus1(bool);
bool getJokerPlus1();
void setDrawTile(bool);
bool getDrawTile();
float getPrintLineScale();
void setPrintLineScale(float);

402
wxwin/gfxboard.cc
View file

@ -1,13 +1,14 @@
/* Eliot */
/* Copyright (C) 1999 Antoine Fraboulet */
/* Antoine.Fraboulet@free.fr */
/* */
/* This program is free software; you can redistribute it and/or modify */
/* This file is part of Eliot. */
/* */
/* Eliot is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or */
/* (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* Eliot 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 General Public License for more details. */
@ -16,6 +17,13 @@
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
/**
* \file gfxboard.cc
* \brief Game board graphical view
* \author Antoine Fraboulet
* \date 2002
*/
#include <string.h>
#include <math.h>
#include <ctype.h>
@ -28,49 +36,79 @@
#include "configdb.h"
#include "gfxboard.h"
#ifdef DEBUG_
# define GFXDEBUG(x) x
#else
# define GFXDEBUG(x)
#endif
BEGIN_EVENT_TABLE(GfxBoard, wxWindow)
EVT_PAINT(GfxBoard::OnPaint)
EVT_SIZE(GfxBoard::OnSize)
END_EVENT_TABLE()
#define LINE_WIDTH 1
#define BOARD_SIZE (BOARD_DIM + 2)
#define LINE_WIDTH 2
#define BOARD_SIZE 17
/* ************************************************** */
/* ************************************************** */
GfxBoard::GfxBoard(wxFrame *parent, Game &iGame) :
wxWindow(parent, -1), m_game(iGame)
wxWindow(parent, wxWindowID(-1), wxDefaultPosition, wxDefaultSize,
wxNO_BORDER | wxFULL_REPAINT_ON_RESIZE, wxT("gfxboard")),
m_game(iGame)
{
bmp = NULL;
board_size = 0;
tile_size = 0;
memset(paintedboard_char,0,sizeof(paintedboard_char));
memset(paintedboard_attr,0,sizeof(paintedboard_attr));
#if defined(MSW_RESIZE_BUG)
just_resized = false;
#endif
for(int i=0; i<BOARD_DIM; i++)
{
for(int j=0; j < BOARD_DIM; j++)
{
paintedboard_char[i][j] = wxT(' ');
paintedboard_attr[i][j] = 0;
}
}
}
/* ************************************************** */
/* ************************************************** */
GfxBoard::~GfxBoard(void)
{
if (bmp)
{
delete bmp;
bmp = NULL;
}
}
/**
* Make new dimensions available for the next OnPaint
* event. The BMP is deleted if it exists.
*/
void
GfxBoard::OnSize(wxSizeEvent& e)
{
size = GetClientSize();
board_size = size.GetWidth() < size.GetHeight() ?
size.GetWidth() : size.GetHeight();
GFXDEBUG(std::cerr << "On size : ");
wxSize cs = GetClientSize();
board_size = cs.GetWidth() < cs.GetHeight() ? cs.GetWidth() : cs.GetHeight();
tile_size = (int)((float)board_size / (float)(BOARD_SIZE)) - LINE_WIDTH;
TopLeft = wxPoint((size.GetWidth() - (board_size - tile_size/2)) / 2,
(size.GetHeight() - (board_size - tile_size/2)) / 2);
GFXDEBUG(std::cerr << "(" << cs.GetWidth() << "," << cs.GetHeight() << ")");
GFXDEBUG(std::cerr << " tile size " << tile_size << endl);
TopLeft = wxPoint((cs.GetWidth() - (board_size - tile_size/2)) / 2,
(cs.GetHeight() - (board_size - tile_size/2)) / 2);
#if defined(MSW_RESIZE_BUG)
just_resized = true;
#endif
if (bmp)
{
@ -79,14 +117,19 @@ GfxBoard::OnSize(wxSizeEvent& e)
}
}
/**
* Creates a BMP in memory and draws the board inside
*/
void
GfxBoard::CreateBMP()
{
GFXDEBUG(std::cerr << "Create BMP ");
if (!bmp)
{
wxSize bs = GetClientSize();
bmp=new wxBitmap(bs.x,bs.y);
GFXDEBUG(std::cerr << " new bmp (" << bs.x << "," << bs.y << ")");
if (bmp)
{
wxMemoryDC memDC;
@ -95,9 +138,58 @@ GfxBoard::CreateBMP()
memDC.SelectObject(wxNullBitmap);
}
}
GFXDEBUG(std::cerr << endl);
}
/**
* Update the full BMP and copy only the requested area
* to the ClientDC
*/
void
GfxBoard::RefreshSquare(wxRect &r)
{
wxClientDC dc(this);
if (bmp)
{
int vX,vY,vW,vH;
wxMemoryDC memDC;
memDC.SelectObject(* bmp);
DrawBoard(&memDC);
vX = r.x;
vY = r.y;
vW = r.width;
vH = r.height;
GFXDEBUG(std::cerr << " refresh (" << vX << "," << vY << "," << vW << "," << vH << ") ");
dc.Blit(vX,vY,vW,vH,&memDC,vX,vY,wxCOPY);
memDC.SelectObject(wxNullBitmap);
}
else
{
DrawBoard(&dc);
}
}
/**
* Force a full refresh of the board
*/
void
GfxBoard::Refresh(board_refresh_t WXUNUSED(force))
{
wxSize cs = GetClientSize();
board_size = cs.GetWidth() < cs.GetHeight() ? cs.GetWidth() : cs.GetHeight();
tile_size = (int)((float)board_size / (float)(BOARD_SIZE)) - LINE_WIDTH;
wxRect r (0,0,cs.GetWidth(),cs.GetHeight());
RefreshSquare(r);
}
/**
* Window manager OnPaint event handler.
*/
void
GfxBoard::OnPaint(wxPaintEvent&)
{
@ -105,151 +197,162 @@ GfxBoard::OnPaint(wxPaintEvent&)
CreateBMP();
GFXDEBUG(std::cerr << "OnPaint : ");
if (bmp)
{
#if defined(MSW_RESIZE_BUG)
Refresh(BOARD_FORCE_REFRESH);
if (just_resized == true)
{
just_resized = false;
}
#else
// we keep that code for wxgtk
// it does not work under wxmsw, don't know why
// all the onsize/repaint should be checked ... later
int vX,vY,vW,vH;
wxMemoryDC memDC;
memDC.SelectObject(* bmp);
wxRegionIterator upd(GetUpdateRegion());
while (upd)
{
vX = upd.GetX();
vY = upd.GetY();
vW = upd.GetW();
vH = upd.GetH();
GFXDEBUG(std::cerr << "+(" << vX << "," << vY << "," << vW << "," << vH << ")");
dc.Blit(vX,vY,vW,vH,&memDC,vX,vY,wxCOPY);
upd ++ ;
}
memDC.SelectObject(wxNullBitmap);
#endif
}
else
{
GFXDEBUG(std::cerr << " call to DrawBoard ");
DrawBoard(&dc);
}
GFXDEBUG(std::cerr << "End of OnPaint" << endl);
}
void
GfxBoard::Refresh(board_refresh_t force)
GfxBoard::DrawTileBack(wxDC* dc, int top, int left, int size, bool testtile)
{
wxClientDC dc(this);
// void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius = 20)
wxBrush oldbrush = dc->GetBrush();
wxColour colBackground;
CreateBMP();
if (force == BOARD_FORCE_REFRESH)
if (testtile)
{
if (bmp)
{
wxMemoryDC memDC;
memDC.SelectObject(* bmp);
DrawBoard(&memDC);
dc.Blit(0,0,board_size,board_size,&memDC,0,0,wxCOPY);
memDC.SelectObject(wxNullBitmap);
colBackground = config.getColour(wxString(BTSTTILEBACKGROUND));
}
else
{
DrawBoard(&dc);
}
return;
colBackground = config.getColour(wxString(BTILEBACKGROUND));
}
if (bmp)
{
int vX,vY,vW,vH;
wxMemoryDC memDC;
memDC.SelectObject(* bmp);
DrawBoard(&memDC);
vX = (tile_size + LINE_WIDTH) * left;
vY = (tile_size + LINE_WIDTH) * top;
vW = (tile_size + 2*LINE_WIDTH) * (right - left + LINE_WIDTH);
vH = (tile_size + 2*LINE_WIDTH) * (bottom - top + LINE_WIDTH);
dc.Blit(vX,vY,vW,vH,&memDC,vX,vY,wxCOPY);
memDC.SelectObject(wxNullBitmap);
}
else
{
DrawBoard(&dc);
}
wxBrush *BackgroundBrush = wxTheBrushList->FindOrCreateBrush(colBackground, wxSOLID);
dc->SetBrush(* BackgroundBrush);
dc->DrawRoundedRectangle(left,top,size,size,std::max(2,size/6));
dc->SetBrush(oldbrush);
}
/**
* Draw a tile to the wxDC object.
*/
#define TILE_LEFT(col) (col*(tile_size+LINE_WIDTH) + TopLeft.x)
#define TILE_TOP(row) (row*(tile_size+LINE_WIDTH) + TopLeft.y)
/*
TODO
- ajuster avec une LINE_SIZE differente
- calculer la taille de la police
*/
/* TILE_LEFT
|
| TILE_LEFT + LINE_WIDTH
| |
+++++++++-- TILE_TOP
+++++++++
+++++++++
+++ +++-------------- TILE_TOP + LINE_WIDTH
+++ +++ | = tile_size
+++ +++--
+++++++++--
+++++++++ | = LINE_WIDTH
+++++++++--
| |
|_|
|
LINE_WIDTH
*/
void
GfxBoard::DrawTile(wxDC *dc, wxString& wxs, int row, int column)
GfxBoard::DrawTile(wxDC *dc, wxString& wxs, int row, int column, bool testtile, bool drawtileback)
{
int l;
char c = 0;
wxColour colour;
wxCoord width, height;
wxCoord posx, posy;
wxCoord left,top;
// redraw borders
if (row && column)
dc->DrawRectangle(column*(tile_size+LINE_WIDTH) + TopLeft.x,
row*(tile_size+LINE_WIDTH) + TopLeft.y,
tile_size + 2*LINE_WIDTH,
tile_size + 2*LINE_WIDTH);
left = TILE_LEFT(column);
top = TILE_TOP(row);
// const char* ptr = wxs.mb_str();
// if (wxs.Len() && isalnum(*ptr))
// {
const char* ptr = (const char*)wxs.c_str();
l = strlen(ptr);
if (ptr)
c = *ptr;
if (l > 0 && isalnum(c))
if (wxs.length() > 0 && *wxs.GetData())
{
// we got a letter (or 2 chars for coordinates > 9)
// draw plastic tile
if (drawtileback)
{
DrawTileBack(dc,
top + LINE_WIDTH,
left + LINE_WIDTH,
tile_size, testtile);
}
// draw letter
if (testtile)
{
colour = config.getColour(wxString(BCOLOURTSTLETTERS));
}
else
{
colour = config.getColour(wxString(BCOLOURLETTERS));
}
dc->SetTextForeground(colour);
dc->GetTextExtent(wxs,&width,&height);
posx = TopLeft.x + column*(tile_size+LINE_WIDTH) + LINE_WIDTH +
(tile_size - width) / 2;
posy = TopLeft.y + row*(tile_size+LINE_WIDTH) + LINE_WIDTH +
(tile_size - height) / 2;
posx = left + LINE_WIDTH + (tile_size - width) / 2;
posy = top + LINE_WIDTH + (tile_size - height) / 2;
dc->DrawText(wxs,posx,posy);
}
}
/**
* Draw the complete board in the wxDC.
*/
void
GfxBoard::DrawBoard(wxDC *dc)
{
Board board;
wxString wxs;
int attr;
int row,column;
left = BOARD_MAX;
right = BOARD_MIN;
top = BOARD_MAX;
bottom = BOARD_MIN;
wxFont font = config.getFont(BOARDFONT);
wxColour colLines = config.getColour(wxString(BCOLOURLINES));
wxColour colLetters = config.getColour(wxString(BCOLOURLETTERS));
wxColour colTestLetters = config.getColour(wxString(BCOLOURTSTLETTERS));
wxColour colForeground = config.getColour(wxString(BCOLOURLINES));
wxColour colBackground = config.getColour(wxString(BCOLOURBACKGROUND));
wxColour colWx3 = config.getColour(wxString(BCOLOURWX3));
wxColour colWx2 = config.getColour(wxString(BCOLOURWX2));
wxColour colLx3 = config.getColour(wxString(BCOLOURLX3));
wxColour colLx2 = config.getColour(wxString(BCOLOURLX2));
wxPen *LinesPen = wxThePenList->FindOrCreatePen(colLines, 1, wxSOLID);
wxBrush *BackgroundBrush = wxTheBrushList->FindOrCreateBrush(colBackground,
wxSOLID);
wxBrush *BackgroundBrush = wxTheBrushList->FindOrCreateBrush(colBackground, wxSOLID);
wxPen *LinesPen = wxThePenList->FindOrCreatePen(colForeground, LINE_WIDTH, wxSOLID);
wxBrush *Wx3Brush = wxTheBrushList->FindOrCreateBrush(colWx3, wxSOLID);
wxBrush *Wx2Brush = wxTheBrushList->FindOrCreateBrush(colWx2, wxSOLID);
wxBrush *Lx3Brush = wxTheBrushList->FindOrCreateBrush(colLx3, wxSOLID);
wxBrush *Lx2Brush = wxTheBrushList->FindOrCreateBrush(colLx2, wxSOLID);
dc->SetFont(font);
LinesPen->SetWidth(LINE_WIDTH);
dc->SetPen(* LinesPen);
dc->SetFont (font);
dc->SetPen (* LinesPen);
dc->SetBrush(* BackgroundBrush);
// background rectangle (entire frame)
@ -257,23 +360,22 @@ GfxBoard::DrawBoard(wxDC *dc)
dc->DrawRectangle(0,0,bs.x,bs.y);
// lines
// dc->DrawRectangle(TopLeft.x,TopLeft.y,board_size - tile_size/2, board_size - tile_size/2);
for(row=BOARD_MIN; row < BOARD_MAX; row++)
{
// vertical
dc->DrawLine(TopLeft.x + (row+1)*(tile_size+LINE_WIDTH),
TopLeft.y + tile_size + LINE_WIDTH,
TopLeft.x + (row+1)*(tile_size+LINE_WIDTH),
TopLeft.y + BOARD_MAX * (tile_size+LINE_WIDTH));
dc->DrawLine(TILE_LEFT(row+1),
TILE_TOP(1),
TILE_LEFT(row+1),
TILE_TOP(BOARD_MAX));
// horizontal row <-> line
dc->DrawLine(TopLeft.x + tile_size+LINE_WIDTH,
TopLeft.y + (row+1)*(tile_size+LINE_WIDTH),
TopLeft.x + BOARD_MAX * (tile_size+LINE_WIDTH),
TopLeft.y + (row+1)*(tile_size+LINE_WIDTH));
dc->DrawLine(TILE_LEFT(1),
TILE_TOP(row+1),
TILE_LEFT(BOARD_MAX),
TILE_TOP(row+1));
}
// 1 2 3 4 5 ...
// A B C D
// A B C D ...
for(row=BOARD_MIN; row <= BOARD_MAX; row++)
{
wxs.Printf(wxT("%d"), row);
@ -282,59 +384,75 @@ GfxBoard::DrawBoard(wxDC *dc)
DrawTile(dc, wxs, row, 0);
}
dc->SetTextForeground(colLetters);
// Board Background
wxColour colWx3 = config.getColour(wxString(BCOLOURWX3));
wxColour colWx2 = config.getColour(wxString(BCOLOURWX2));
wxColour colLx3 = config.getColour(wxString(BCOLOURLX3));
wxColour colLx2 = config.getColour(wxString(BCOLOURLX2));
wxBrush *Wx3Brush = wxTheBrushList->FindOrCreateBrush(colWx3, wxSOLID);
wxBrush *Wx2Brush = wxTheBrushList->FindOrCreateBrush(colWx2, wxSOLID);
wxBrush *Lx3Brush = wxTheBrushList->FindOrCreateBrush(colLx3, wxSOLID);
wxBrush *Lx2Brush = wxTheBrushList->FindOrCreateBrush(colLx2, wxSOLID);
board = m_game.getBoard();
for(row=BOARD_MIN; row <= BOARD_MAX; row++)
{
for (column = BOARD_MIN; column <= BOARD_MAX; column++)
{
if (m_game.getBoard().getLetterMultiplier(row, column) == 2)
if (board.getLetterMultiplier(row, column) == 2)
{
dc->SetBrush(*Lx2Brush);
dc->SetTextBackground(colLx2);
}
else if (m_game.getBoard().getLetterMultiplier(row, column) == 3)
else if (board.getLetterMultiplier(row, column) == 3)
{
dc->SetBrush(*Lx3Brush);
dc->SetTextBackground(colLx3);
}
else if (m_game.getBoard().getWordMultiplier(row, column) == 2)
else if (board.getWordMultiplier(row, column) == 2)
{
dc->SetBrush(*Wx2Brush);
dc->SetTextBackground(colWx2);
}
else if (m_game.getBoard().getWordMultiplier(row, column) == 3)
else if (board.getWordMultiplier(row, column) == 3)
{
dc->SetBrush(*Wx3Brush);
dc->SetTextBackground(colWx3);
}
wxs = wxString((wxChar)m_game.getBoard().getChar(row, column));
attr = m_game.getBoard().getCharAttr(row, column);
if ((paintedboard_char[row - BOARD_MIN][column - BOARD_MIN] != wxs.GetChar(0)) ||
(paintedboard_attr[row - BOARD_MIN][column - BOARD_MIN] != attr))
{
top = top < row ? top : row;
bottom = bottom > row ? bottom : row;
left = left < column ? left : column;
right = right > column ? right : column;
paintedboard_char[row - BOARD_MIN][column - BOARD_MIN] = wxs.GetChar(0);
paintedboard_attr[row - BOARD_MIN][column - BOARD_MIN] = attr;
}
if (attr & ATTR_TEST)
{
dc->SetTextForeground(colTestLetters);
DrawTile(dc,wxs,row,column);
dc->SetTextForeground(colLetters);
}
else
{
DrawTile(dc,wxs,row,column);
dc->SetBrush(*BackgroundBrush);
}
dc->SetBrush(* BackgroundBrush);
dc->SetTextBackground(colBackground);
if (row && column)
{
dc->DrawRectangle(TILE_LEFT(column), TILE_TOP(row),
tile_size + 2*LINE_WIDTH,
tile_size + 2*LINE_WIDTH);
}
}
}
// Tiles
LinesPen->SetWidth(1);
dc->SetPen (* LinesPen);
bool drawtiles = config.getDrawTile();
for(row=BOARD_MIN; row <= BOARD_MAX; row++)
{
for (column = BOARD_MIN; column <= BOARD_MAX; column++)
{
int attr = board.getCharAttr(row, column);
wxs = wxString((wxChar)board.getChar(row, column));
paintedboard_char[row - BOARD_MIN][column - BOARD_MIN] = *wxs.GetData();
paintedboard_attr[row - BOARD_MIN][column - BOARD_MIN] = attr;
DrawTile(dc,wxs,row,column,attr & ATTR_TEST,drawtiles);
}
}
dc->SetFont(wxNullFont);
}
/// Local Variables:
/// mode: hs-minor
/// c-basic-offset: 4
/// End:

93
wxwin/gfxboard.h
View file

@ -1,13 +1,14 @@
/* Eliot */
/* Copyright (C) 1999 Antoine Fraboulet */
/* Antoine.Fraboulet@free.fr */
/* */
/* This program is free software; you can redistribute it and/or modify */
/* This file is part of Eliot. */
/* */
/* Eliot is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or */
/* (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* Eliot 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 General Public License for more details. */
@ -26,45 +27,89 @@
#ifndef _GFXBOARD_H
#define _GFXBOARD_H
/*
paintedboard_char is the matrix of played tiles
paintedboard_attr is the matrix of special attributes for tiles, for
instance it can store if a tile is a test tile (placed but not played).
/**
* gfxboard is a wxWindow widget that draws a Scrabble board
*/
typedef enum {
BOARD_REFRESH,
BOARD_FORCE_REFRESH
} board_refresh_t;
class GfxBoard : public wxWindow
{
private:
private:
/**
* reference on the played game
*/
Game &m_game;
int top,bottom,left,right;
char paintedboard_char[BOARD_DIM][BOARD_DIM];
/**
* paintedboard_char is the matrix of played tiles
*/
wxChar paintedboard_char[BOARD_DIM][BOARD_DIM];
/**
* paintedboard_attr is the matrix of special attributes for tiles, for
* instance it can store if a tile is a test tile (placed but not played).
*/
char paintedboard_attr[BOARD_DIM][BOARD_DIM];
/**
* size in pixels for the board.
* board_size = min(width,height)
*/
int board_size;
/**
* tile_size = size in pixels of a tile
*/
int tile_size;
/**
* there is a bug when doing an OnSize under windows : the window
* has to be fully refreshed (UpdateRegion does not seem to work).
*/
#if defined(MSW_RESIZE_BUG)
bool just_resized;
#endif
/**
* top left point used to draw the lines, used to keep the board
* centered horizontally and vertically
*/
wxPoint TopLeft;
wxSize size;
/**
* Board bitmap, created by CreateBMP
*/
wxBitmap *bmp;
void CreateBMP();
void DrawTile(wxDC*,wxString&,int,int);
void DrawTileBack(wxDC*,int,int,int, bool testtile);
void DrawTile(wxDC*,wxString&,int,int,bool testtile = false, bool drawtileback = false);
void DrawBoard(wxDC*);
void RefreshSquare(wxRect&);
ConfigDB config;
public:
GfxBoard(wxFrame*, Game&);
public:
GfxBoard(wxFrame* parent, Game& game);
~GfxBoard(void);
void Refresh(board_refresh_t force = BOARD_REFRESH);
void OnPaint(wxPaintEvent& event);
void OnSize(wxSizeEvent& event);
void OnPaint (wxPaintEvent& event);
void OnSize (wxSizeEvent& event);
typedef enum {
BOARD_REFRESH,
BOARD_FORCE_REFRESH
} board_refresh_t;
void Refresh (board_refresh_t force = BOARD_REFRESH);
DECLARE_EVENT_TABLE()
};
#endif
/// Local Variables:
/// mode: hs-minor
/// c-basic-offset: 4
/// End: