/**************/
/* tausta.c   */
/****************************************************************************
  PROGRAM: tausta.c
  PURPOSE: Aliohjelmakirjasto taustan piirtämiseksi.
  AUTHOR:  Vesa Lappalainen 20.10.1992
           20.8.1994/vl : ikkunakohtaiset taustat ja viestitaulukon pala
           21.11.1994/vl: täyttö monella bittikartalla

  USAGE:   Käyttäjän pitää
    0) Liittää projektiin ALI\tausta.c ja pääohjelmaan #include "tausta.h"

    1) liittää .RC tiedostoonsa haluttujen taustan bittikartta esim. nimellä
       TAUSTA

    2) Kutsua ikkunan luomisessa (esim. WM_INITDIALOG)
          AlustaTausta(hInstance,"TAUSTA");

       Tätä voidaan kutsua myös myöhemmin taustan vaihtamiseksi.
          AlustaTausta(NULL,"UUSITAUSTA");

    3) Taustan hoitamiseksi kutsua ikkunan funktiossa
          case WM_ERASEBKGND:
            PiirraTausta((HDC)wParam);
            return TRUE;
       Tai laittaa EV_HANDLE_WM_ERASEBKGND rivi MsgTbl -taulukkoon
       (ks. TABHAND.H)

    4) Ohjelman lopuksi kutsua
          PoistaTausta();

    2*)      Jos käytetään ikkunakohtaisia taustoja, niin ne luodaan kutsulla
                AlustaTaustaHWND(hInstance,hWnd,"TAUSTA",1);
             ( 0 = ei venytystä, 1 = venytetään ikkunan kokoiseksi,
               2 = tayta monelle kunnes tulee täyteen )
    3* & 4*) Jos viestitaulukkoon lisätään rivi
               LOOK_TABLE(TaustaMsgTbl)
             ei muuta tarvitse tehdäkään.

             Myös ikkunakohtaisessa tapauksessa voidaan luoda vielä
             ikkunaton tausta, jota käytetään niille ikkunoille, joille
             ei ole erikseen luotu ikkunakohtaista taustaa.  Tämä "ikkunaton"
             tausta pitää kuitenkin erikseen poistaa!

    Kaikki funktiot palauttavat 0=OK, muut on virhe.

    Muita funktioita:
     int TaytaBittikarttalla(HWND hWnd,HDC hDC,HBITMAP hBitmap);
     int PiirraBittikartta(HDC hDC,HBITMAP hBitmap,int x,int y)

Suunitelmia:
------------
 - täytössä nopeampi käyttö automaattisen talletuksen avulla

****************************************************************************/
#include <windows.h>            /* Tarvitaan kaikissa Windows C-ohjelmissa */
#include "tabhand.h"
#include "tausta.h"

/***************************************************************************/
static HINSTANCE GhInstance = NULL;

int TaytaMonellaBittikartalla(HWND hWnd,HDC hDC,HBITMAP hBitmap)
{
  HDC  hDCBitmap = CreateCompatibleDC(hDC);
  HGDIOBJ hOld  = SelectObject(hDCBitmap,hBitmap);
  RECT rc;
  BITMAP bm;
  int x,y;

  GetObject(hBitmap,sizeof(bm),&bm);
  GetClientRect(hWnd,&rc);
  for (y=0; y<rc.bottom; y+=bm.bmHeight)
    for (x=0; x<rc.right; x+=bm.bmWidth)
      BitBlt(hDC,x,y,bm.bmWidth,bm.bmHeight,hDCBitmap,0,0,SRCCOPY);

  SelectObject(hDCBitmap,hOld);
  DeleteDC(hDCBitmap);
  return 0;
}

/***************************************************************************/
int TaytaBittikartalla(HWND hWnd,HDC hDC,HBITMAP hBitmap)
/* Täytetään koko alue bittikartalla                                       */
{
  HDC  hDCBitmap = CreateCompatibleDC(hDC);
  HGDIOBJ hOld  = SelectObject(hDCBitmap,hBitmap);
  RECT rc;
  BITMAP bm;

  GetObject(hBitmap,sizeof(bm),&bm);
  GetClientRect(hWnd,&rc);
  StretchBlt(hDC,0,0,rc.right,rc.bottom,hDCBitmap,
                 0,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
  SelectObject(hDCBitmap,hOld);
  DeleteDC(hDCBitmap);
  return 0;
}

/***************************************************************************/
int PiirraBittikartta(HDC hDC,HBITMAP hBitmap,int x,int y)
/* Piirretään bittikartta alkaen paikasta x,y                              */
{
  HDC  hDCBitmap = CreateCompatibleDC(hDC);
  HGDIOBJ hOld   = SelectObject(hDCBitmap,hBitmap);
  BITMAP bm;

  GetObject(hBitmap,sizeof(bm),&bm);
  BitBlt(hDC,x,y,bm.bmWidth,bm.bmHeight,hDCBitmap,0,0,SRCCOPY);
  SelectObject(hDCBitmap,hOld);
  DeleteDC(hDCBitmap);
  return 0;
}

/***************************************************************************/
#define MAX_TAUSTOJA  10
typedef struct {
  int     tayta;
  HWND    hWnd;
  HBITMAP hBitBack;
} tTausta;

static int taustoja = 0;
static tTausta Taustat[MAX_TAUSTOJA];

int LisaaTausta(HWND hWnd,int tayta,HBITMAP hBitBack)
{
  int i;
  for (i=0; i<taustoja; i++)  if ( Taustat[i].hWnd == hWnd ) return 0;
  if ( taustoja >= MAX_TAUSTOJA ) return 1;
  Taustat[taustoja].tayta     = tayta;
  Taustat[taustoja].hWnd      = hWnd;
  Taustat[taustoja].hBitBack  = hBitBack;
  taustoja++;
  return hBitBack == NULL;
}

static int onko_tayta(HWND hWnd)
{
  int i;
  for (i=0; i<taustoja; i++)
    if ( Taustat[i].hWnd == hWnd ) return Taustat[i].tayta;
  for (i=0; i<taustoja; i++)
    if ( Taustat[i].hWnd == NULL ) return Taustat[i].tayta;
  return 0;
}

static HBITMAP htausta(HWND hWnd)
{
  int i;
  for (i=0; i<taustoja; i++)
    if ( Taustat[i].hWnd == hWnd ) return Taustat[i].hBitBack;
  for (i=0; i<taustoja; i++)
    if ( Taustat[i].hWnd == NULL ) return Taustat[i].hBitBack;
  return NULL;
}

/***************************************************************************/
int PoistaTaustaHWND(HWND hWnd)
{
  int i,j;
  for (i=0; i<taustoja; i++)
    if ( Taustat[i].hWnd == hWnd ) {
      if ( Taustat[i].hBitBack ) {
        DeleteObject(Taustat[i].hBitBack);
        Taustat[i].hBitBack = NULL;
      }
      for (j=i+1; j<taustoja; j++) Taustat[j-1] = Taustat[j];
      taustoja--;
      return 0;
    }
  return 1;
}

/***************************************************************************/
static int TutkiEsiintyma(HINSTANCE *hInstance, HWND hWnd)
{
  if ( !*hInstance )
    if ( !GhInstance ) *hInstance = GetWindowInstance(hWnd);
    else               *hInstance = GhInstance;
  GhInstance = *hInstance;
  if ( GhInstance == NULL ) return 1;
  return 0;
}

/***************************************************************************/
int PiirraTaustaHWND(HWND hWnd,HDC hDC)
/* Piirretään valittu taustakuva ikkunan alueelle.                         */
/* Ison bittikartan venyttäminen kestää kauan ja ant. myös huon. tul.      */
/* TaytaBittikartalla(hWnd,(HDC)wParam,hBitBack);                          */
{
  HBITMAP hBitBack = htausta(hWnd);
  if ( !hBitBack ) return 1;
  switch ( onko_tayta(hWnd) ) {
    case 1:  return TaytaBittikartalla(hWnd,hDC,hBitBack);
    case 2:  return TaytaMonellaBittikartalla(hWnd,hDC,hBitBack);
    default: return PiirraBittikartta(hDC,hBitBack,0,0);
  }
}

/***************************************************************************/
int AlustaTaustaHWND(HINSTANCE hInstance, HWND hWnd, char *pTausta,int tayta)
/* Alustetaan ikoni ja tausta.  Jos esiintymää ei anneta, käytetään ed.    */
/* Aluksi poistetaan varulta vanhat jotta tätä voi käyttää myös            */
/* vaihtamiseen                                                            */
{
  HBITMAP hBitBack = NULL;
  if ( TutkiEsiintyma(&hInstance,hWnd) ) return 1;
  if ( pTausta ) hBitBack = LoadBitmap(hInstance,pTausta);
  PoistaTaustaHWND(hWnd);
  return LisaaTausta(hWnd,tayta,hBitBack);
}

/***************************************************************************/
static EVENT WM_erasebkgnd(tMSGParam *msg)
{
  return PiirraTaustaHWND(msg->hWnd,(HDC)msg->wParam);
}

/***************************************************************************/
static EVENT WM_destroy(tMSGParam *msg)
{
  PoistaTaustaHWND(msg->hWnd);
  return CONTINUE_TABLE;
}

/***************************************************************************/
tMSGEntry TaustaMsgTbl[] = {
  { WM_ERASEBKGND , DoC , DoC , WM_erasebkgnd }, /*a*/
  { WM_DESTROY , DoC , DoC , WM_destroy }, /*a*/
  { 0 }
};