/**************/
/* clipboard.c*/
/****************************************************************************
  PROGRAM: clipboard
  PURPOSE: helpottaa leikekirjan käyttöä
           (toistaiseksi tekstimuotoisen datan siirrossa)
  AUTHOR:  Vesa Lappalainen 13.8.1993
  USAGE:
    Projektiin lisättävä clipboard.c.

    Leikekirjan käyttämiseksi: 

    1) Datan laittamiseksi leikekirjaan kutsutaan
          AddToClipboard(hWnd,CF_TEXT,data,datalen,TRUE);                                         
       Viimeinen parametri on TRUE/FALSE sen mukaan halutaanko leikekirja
       tyhjentää vai ei.

       Tälle on myös tekstiä varten makroversio
          TextToClipboard(hWnd,s);
  
    2) Datan ottamiseksi leikekirjasta kutsutaan:
          char *data=CopyFromClipboardN(hWnd,CF_TEXT,&n);

       Tulos on NULL tai osoitin staattiseen muuttujaan, josta
       tulos on kopioitava heti pois.  Tuloksen maksimikoko
       on rajoitettu (ks. MAX_COPY), joten jos halutaan isompia
       kopiota, pitää käyttää omaa pukuria ja versiota DataFromClipboardN.
       Osoitteeseen n laitetaan leikekirjan datan koko (tai se
       mitä sieltä saatiin otettua)

       Tälle on myös makroversio
          ...=CopyFromClipboard(hWnd,CF_TEXT);

       koska jos osoite on NULL, ei kokoa palauteta missään.
       Tekstiä varten on lisäki makroversio
          ...=TextClipboard(hWnd);

    2b)Datan ottamiseksi omaan puskuriin on versio
          char oma[200];
          char *p=DataFormClipboardN(hWnd,CF_TEXT,&n,oma,sizeof(oma));

       Tästä on myös makroversio
          ...=DataFromClipboard(hWnd,CF_TEXT,oma);

       jossa oletetaan aina käytettäväksi muotoa sizeof(oma)
       Tekstiä varten on vielä makroversiot
          ...=TextFromClipboard(hWnd,oma);

    3) Tarvittaessa varata isoa puskuria, voidaan leikekirjan koko
       selvittää ennen varausta kutsulla
         size = ClipboardDataSize(hWnd,fmt);

****************************************************************************/
#include <windows.h>
#include <string.h>
#include "clipboar.h"
#define MAX_COPY 500

static textfmts[] = { CF_TEXT,CF_SYLK,CF_OEMTEXT, CF_DSPTEXT ,0 };
/***************************************************************************/
static int TextFmt(UINT fmt)
{
  int i;
  for (i=0; textfmts[i]; i++)
    if ( (UINT)textfmts[i] == fmt ) return TRUE;
  return FALSE;
}


/***************************************************************************/
DWORD ClipboardDatasize(HWND hWnd,UINT fmt)
/* Palautetaan leikekirjan datan koko.  Jos hWnd=NULL, oletetaan leikekirjan
** jo olevan auki, eikä sitä avata eikä suljeta.
** Koko saattaa olla hieman liian iso, koska muistilohkolle varattu tila
** voi olla suurempi kuin tarvittava tila (vrt. GlobalAlloc).
** Jos tapahtuu virhe, palautetaan -1, eli koko 0 tarkoittaa formaatin
** olevan olemassa, mutta koon olevan todella 0.
*/
{
  HANDLE hClipData;
  DWORD   gsize;

  if ( hWnd && !OpenClipboard(hWnd) ) return -1;
  if ( !IsClipboardFormatAvailable(fmt) ) return -1;

  /* get data from the clipboard */
  if ( (hClipData = GetClipboardData(fmt)) == NULL )  {
    if ( hWnd ) CloseClipboard();
    return -1;
  }

  gsize = GlobalSize(hClipData);
  if ( hWnd ) CloseClipboard();

  return gsize;
}


/***************************************************************************/
char *DataFromClipboardN(HWND hWnd,UINT fmt,UINT *n,char *buf, UINT bufm)
/* Otetaan tieto leikekirjasta.  Jos hWnd=NULL, oletetaan leikekirjan
** jo olevan auki, eikä sitä avata eikä suljeta.
** Jos muoto on tekstiformaattia, on koko jonon pituus.
*/
{
  HANDLE hClipData;
  char FAR *lpClipData;
  DWORD gsize,size = bufm-1;
  if ( n ) *n = 0;
  buf[0]=0;

  if ( !fmt ) return NULL;
  if ( hWnd && !OpenClipboard(hWnd) ) return NULL;
  if ( !IsClipboardFormatAvailable(fmt) ) {
    if ( hWnd ) CloseClipboard();
    return NULL;
  }

  /* get data from the clipboard */
  if ( (hClipData = GetClipboardData(fmt)) == NULL )  {
    if ( hWnd ) CloseClipboard();
    return NULL;
  }

  gsize = GlobalSize(hClipData);
  if ( (lpClipData = GlobalLock(hClipData)) == NULL )  {
     if ( hWnd ) CloseClipboard();
     return NULL;
  }

  if ( gsize < size ) size=gsize;
  _fmemcpy(buf, lpClipData,(UINT)size);
  buf[(UINT)size] = 0;

  GlobalUnlock(hClipData);
  if ( hWnd ) CloseClipboard();

  if ( TextFmt(fmt) ) size = strlen(buf);

  if ( n ) *n = (UINT)size;

  return buf;
}


/***************************************************************************/
const char *CopyFromClipboardN(HWND hWnd,UINT fmt,UINT *n)
{
  static char pText[MAX_COPY];
  return DataFromClipboardN(hWnd,fmt,n,pText,sizeof(pText));
}


/***************************************************************************/
int AddToClipboard(HWND hWnd,UINT fmt,const char *Text,int len,BOOL empty)
/* Lisätään leikekirjaan data Text, josta otetaan len tavua.
** Jos hWnd == NULL, oletetaan leikekirjan olevan avoinna.
** Jos empty==TRUE, niin leikekirja tyhjennetään ennen lisäystä.
** Palautetaan != 0 jos lisäys ei onnistu.
*/
{
  HANDLE hData;
  char FAR *lpData;

  if ( (hData = GlobalAlloc(GMEM_MOVEABLE, len)) == NULL ) return -1;
  if ( (lpData = GlobalLock(hData)) == NULL || (hWnd && !OpenClipboard(hWnd)) ) {
    GlobalFree(hData);
    return -2;
  }

  _fmemcpy(lpData, Text,len);
  GlobalUnlock(hData);

  if ( empty ) EmptyClipboard();
  SetClipboardData(fmt, hData);
  if ( hWnd ) CloseClipboard();

  return 0;
}


/***************************************************************************/
UINT FindClipboardFormat(const char *name)
/* Etsitään leikekirjan formaatti ja jos ei löydy, lisätään formaatti
*/
{
  UINT fmt=0;  char n[50];

  while ( (fmt = EnumClipboardFormats(fmt)) != 0 )
    if ( GetClipboardFormatName(fmt,n,sizeof(n)) && strcmpi(n,name) == 0 )
      return fmt;
  return RegisterClipboardFormat(name);
}


/***************************************************************************/
int AddLinkToClipboard(HWND hWnd,const char *linkText,const char *linkType,BOOL empty)
/* Lisätään leikekirjaan linkki, eli ilmoitus siitä, mistä linkitetään
** ja myös vastaava näyttöteksti (Clipboard vieweria varten).
** Palautetaan 0 jos homma onnistuu.
** Link-toiminnon tunnistavat ohjelmat haluavat linkin leikekirjaan
** muodossa: service NUL topic NUL item NUL NUL (itse tutkittu!)
*/
{
  UINT linkFmt = FindClipboardFormat(linkType);
  char pText[100],*p; /* OMA|LKM!HA -> OMA\0LKM\0HA\0\0                    */
  int plen;
  int ret;

  if ( !linkFmt ) return -3;
  if ( hWnd && !OpenClipboard(hWnd) ) return -2;

  strncpy(pText,linkText,sizeof(pText)-1); pText[sizeof(pText)-2]=0;
  plen=strlen(pText)+1;
  pText[plen++]=0;                                  /* Lisätään toinen NUL */
  p = strchr(pText,'!'); if (p) *p=0;               /* Jälkimmäinen ensin  */
  p = strchr(pText,'|'); if (p) *p=0;               /* jottei jono katkea! */

  ret = AddToClipboard(NULL,linkFmt,pText,plen,empty);
  if ( !ret )
    ret = AddToClipboard(NULL,CF_DSPTEXT,linkText,strlen(linkText)+1,0);

  if ( hWnd ) CloseClipboard();

  return ret;
}


/***************************************************************************/
const char *TakeLinkFromClipboard(HWND hWnd,const char *linkType,
			    const char **ser, const char **top, const char **item)
/* Luetaan leikekirjassa oleva linkkitieto.
** Palautetaan teksti OMA|LKM!HA
** ja osoittimet teksteihin ser=OMA top=LKM item=HA
** Kaikki palautettavat merkkijonot ovat staattisia muuttujia, joiden
** sisältö pitää kopioida heti muualle.
*/
{
  UINT linkFmt = FindClipboardFormat(linkType);
  const char *p = CopyFromClipboardN(hWnd,linkFmt,NULL);
  static char ltext[100];
  int l;

  if ( !p ) return NULL;

  if ( ser ) *ser = p;
  strcpy(ltext,p);  l=strlen(ltext);
  ltext[l++] = '|'; if ( top ) *top = p+l;
  strcpy(ltext+l,p+l); l=strlen(ltext);
  ltext[l++] = '!'; if ( item ) *item = p+l;
  strcpy(ltext+l,p+l);

  return ltext;
}