[Eliot-dev] Changes to eliot/wxwin/gfxboard.cc [antoine-1]

[eliot-dev]

Index: eliot/wxwin/gfxboard.cc
diff -u /dev/null eliot/wxwin/gfxboard.cc:1.5.2.1
--- /dev/null   Sun Oct 23 17:10:59 2005
+++ eliot/wxwin/gfxboard.cc     Sun Oct 23 17:10:46 2005
@@ -0,0 +1,460 @@
+/* Eliot                                                                     */
+/* Copyright (C) 1999  Antoine Fraboulet                                     */
+/*                                                                           */
+/* 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.                                       */
+/*                                                                           */
+/* 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.                              */
+/*                                                                           */
+/* You should have received a copy of the GNU General Public License         */
+/* along with this program; if not, write to the Free Software               */
+/* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
*/
+
+/* $Id: gfxboard.cc,v 1.5.2.1 2005/10/23 17:10:46 afrab Exp $ */
+
+/**
+ *  \file gfxboard.cc
+ *  \brief  Game board graphical view
+ *  \author Antoine Fraboulet
+ *  \date   2002
+ */
+
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+
+#include "wx/dcmemory.h"
+
+#include "ewx.h"
+#include "dic.h"
+#include "game.h"
+#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)
+
+    /* ************************************************** */
+    /* ************************************************** */
+
+GfxBoard::GfxBoard(wxFrame *parent, 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;
+#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)
+{
+    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;
+
+    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)
+       {
+           delete bmp;
+           bmp = NULL;
+       }
+}
+
+/**
+ * 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;
+                   memDC.SelectObject(* bmp);
+                   DrawBoard(&memDC);
+                   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&)
+{
+    wxPaintDC dc(this);
+
+    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::DrawTileBack(wxDC* dc, int top, int left, int size, bool testtile)
+{
+    //    void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, 
wxCoord height, double radius = 20)
+    wxBrush oldbrush = dc->GetBrush();
+    wxColour colBackground;
+
+    if (testtile)
+       {
+           colBackground = config.getColour(wxString(BTSTTILEBACKGROUND));
+       }
+    else
+       {
+           colBackground = config.getColour(wxString(BTILEBACKGROUND));
+       }
+
+    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, bool 
testtile, bool drawtileback)
+{
+    wxColour colour;
+    wxCoord width, height;
+    wxCoord posx, posy;
+    wxCoord left,top;
+    // redraw borders 
+    left = TILE_LEFT(column);
+    top  = TILE_TOP(row);
+    
+    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 = 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 row,column;
+
+    wxFont   font            = config.getFont(BOARDFONT);
+    wxColour colForeground   = config.getColour(wxString(BCOLOURLINES));
+    wxColour colBackground   = config.getColour(wxString(BCOLOURBACKGROUND));
+
+    wxBrush *BackgroundBrush = 
wxTheBrushList->FindOrCreateBrush(colBackground, wxSOLID);
+    wxPen   *LinesPen        = wxThePenList->FindOrCreatePen(colForeground, 
LINE_WIDTH, wxSOLID);
+
+    dc->SetFont (font);
+    dc->SetPen  (* LinesPen);
+    dc->SetBrush(* BackgroundBrush);
+
+    // background rectangle (entire frame)
+    wxSize bs = GetClientSize();
+    dc->DrawRectangle(0,0,bs.x,bs.y);
+
+    // lines
+    for(row=BOARD_MIN; row < BOARD_MAX; row++)
+       {
+           // vertical
+           dc->DrawLine(TILE_LEFT(row+1),
+                        TILE_TOP(1),
+                        TILE_LEFT(row+1),
+                        TILE_TOP(BOARD_MAX));
+           // horizontal row <-> line
+           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 ...
+    for(row=BOARD_MIN; row <= BOARD_MAX; row++)
+       {
+           wxs.Printf(wxT("%d"), row);
+           DrawTile(dc, wxs, 0, row);
+           wxs.Printf(wxT("%c"), row + 'A' - 1);
+           DrawTile(dc, wxs, row, 0);
+       }
+
+    // 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 (board.getLetterMultiplier(row, column) == 2)
+                       {
+                           dc->SetBrush(*Lx2Brush);
+                       }
+                   else if (board.getLetterMultiplier(row, column) == 3)
+                       {
+                           dc->SetBrush(*Lx3Brush);
+                       }
+                   else if (board.getWordMultiplier(row, column) == 2)
+                       {
+                           dc->SetBrush(*Wx2Brush);
+                       }
+                   else if (board.getWordMultiplier(row, column) == 3)
+                       {
+                           dc->SetBrush(*Wx3Brush);
+                       }
+                   else 
+                       {
+                           dc->SetBrush(*BackgroundBrush);
+                       }
+
+                   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: