accelkey.c

在ｅｃｏｓ 下mingui 的移植开发

// $Id: accelkey.c,v 1.3 2000/06/20 01:36:29 weiym Exp $
//
// accelkey.c: The Accelerator module.
//
// Copyright (C) 1999, Kang Xiaoning.
// Copyright (C) 1999, Wei Yongming.
//
// Current maintainer: Wei Yongming.

/*
**  This library is free software; you can redistribute it and/or
**  modify it under the terms of the GNU Library General Public
**  License as published by the Free Software Foundation; either
**  version 2 of the License, or (at your option) any later version.
**
**  This library 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
**  Library General Public License for more details.
**
**  You should have received a copy of the GNU Library General Public
**  License along with this library; if not, write to the Free
**  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
**  MA 02111-1307, USA
*/

// Create date: 1999.04.19
//
// Modify records:
//
//  Who             When        Where       For What                Status
//-----------------------------------------------------------------------------
//
// TODO:
// 

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>


#include "common.h"
#include "gdi.h"
#include "window.h"
#include "cliprect.h"
#include "gal.h"
#include "internals.h"
#include "accelkey.h"

#ifndef lint
static char fileid[] = "$Id: accelkey.c,v 1.3 2000/06/20 01:36:29 weiym Exp $";
#endif

static FREEAILIST FreeAIList;
static FREEACLIST FreeACList;

// copy from menu.c :pp
// acceltable construction 
static BOOL InitFreeACList(void)
{
    if( !(FreeACList.heap = malloc (sizeof(ACCELTABLE)*SIZE_AC_HEAP))) 
        return FALSE;
        
    FreeACList.free = 0;

    pthread_mutex_init (&FreeACList.lock, NULL);
    FreeACList.head = FreeACList.tail = NULL;
    FreeACList.nr = 0;

    return TRUE;
}

static PACCELTABLE AccelTableAlloc(void)
{
    PACCELTABLE pac;

    pthread_mutex_lock (&FreeACList.lock);

    if (FreeACList.head) {
        pac = FreeACList.head;
        FreeACList.head = pac->next;
        FreeACList.nr --;
    }
    else {
        if (FreeACList.free < SIZE_AC_HEAP) {
            pac = FreeACList.heap + FreeACList.free;
            pac->fromheap = TRUE;
            FreeACList.free ++;
        }
        else {
            pac = malloc (sizeof(ACCELTABLE));
            if (pac == NULL)
                fprintf (stderr, "ACCELTBL error: alloc accel table failure!\n");
            else
                pac->fromheap = FALSE;
        }
    }

    pthread_mutex_unlock (&FreeACList.lock);

    return pac;
}

static void FreeAccelTable(PACCELTABLE pac)
{

    pthread_mutex_lock (&FreeACList.lock);

    pac->next = NULL;
    if (FreeACList.head) {
        FreeACList.tail->next = pac;
        FreeACList.tail = pac;
    }
    else {
        FreeACList.head = FreeACList.tail = pac; 
    }

    FreeACList.nr++;
    pthread_mutex_unlock (&FreeACList.lock);
}

static void EmptyFreeACList(void)
{
    PACCELTABLE pac, pTemp;

    pthread_mutex_lock (&FreeACList.lock);

    pac = FreeACList.head;

    while (pac) {
        pTemp = pac->next;
        
        if (!pac->fromheap)
            free (pac);

        pac = pTemp;
    }

    FreeACList.head = FreeACList.tail = NULL;
    FreeACList.nr = 0;
    FreeACList.free = 0;

    pthread_mutex_unlock (&FreeACList.lock);
}

static void DestroyFreeACList(void)
{
    EmptyFreeACList ();
    free (FreeACList.heap);
}

// accelkey item routeline 
static BOOL InitFreeAIList(void)
{
    if( !(FreeAIList.heap = malloc (sizeof(ACCELITEM)*SIZE_AI_HEAP))) 
        return FALSE;
        
    FreeAIList.free = 0;

    pthread_mutex_init (&FreeAIList.lock, NULL);
    FreeAIList.head = FreeAIList.tail = NULL;
    FreeAIList.nr = 0;

    return TRUE;
}

static PACCELITEM AccelItemAlloc(void)
{
    PACCELITEM pai;

    pthread_mutex_lock (&FreeACList.lock);

    if (FreeAIList.head) {
        pai = FreeAIList.head;
        FreeAIList.head = pai->next;
        FreeAIList.nr --;
    }
    else {
        if (FreeAIList.free < SIZE_AI_HEAP) {
            pai = FreeAIList.heap + FreeAIList.free;
            pai->fromheap = TRUE;
            FreeAIList.free ++;
        }
        else {
            pai = malloc (sizeof(ACCELITEM));
            if (pai == NULL)
                fprintf (stderr, "Accel item error: alloc accelkey item failure!\n");
            else
                pai->fromheap = FALSE;
        }
    }

    pthread_mutex_unlock (&FreeAIList.lock);

    return pai;
}

static void FreeAccelItem(ACCELITEM* pai)
{
    pthread_mutex_lock (&FreeACList.lock);

    pai->next = NULL;
    if (FreeAIList.head) {
        FreeAIList.tail->next = pai;
        FreeAIList.tail = pai;
    }
    else {
        FreeAIList.head = FreeAIList.tail = pai;
    }

    FreeAIList.nr++;
    pthread_mutex_unlock (&FreeAIList.lock);
}

static void EmptyFreeAIList(void)
{
    PACCELITEM pai, pTemp;

    pthread_mutex_lock (&FreeACList.lock);

    pai = FreeAIList.head;

    while (pai) {
        pTemp = pai->next;
        
        if (!pai->fromheap)
            free (pai);

        pai = pTemp;
    }

    FreeAIList.head = FreeAIList.tail = NULL;
    FreeAIList.nr = 0;
    FreeAIList.free = 0;

    pthread_mutex_unlock (&FreeAIList.lock);
}

static void DestroyFreeAIList(void)
{
    EmptyFreeAIList ();
    free (FreeAIList.heap);
}

DWORD mergeKeymask(DWORD keymask)
{
   DWORD result = 0;
   if (keymask & 3) result |= ACCEL_SHIFT;
   if (keymask & 12) result |= ACCEL_ALT;
   if (keymask & 48) result |= ACCEL_CTRL;
   return result;
}
               

BOOL InitAccel (void)
{
    if (!InitFreeACList ()) return FALSE;

    if (!InitFreeAIList ()) return FALSE;

    return TRUE;
}


void TerminateAccel (void)
{
 
    DestroyFreeACList ();
    DestroyFreeAIList ();
  
}

/*********  interfaces  ************************************/

HACCEL GUIAPI LoadAccelerators(const char* filename, int id)
{
    return 0;
}

HACCEL GUIAPI CreateAcceleratorTable (HWND hWnd)
{
    PACCELTABLE pac;

    if (!(pac = AccelTableAlloc ()))
        return 0;
    
    pac->class = TYPE_HACCEL;
    pac->hwnd = hWnd;
    pac->head = NULL;

    return (HACCEL)pac;
}

int GUIAPI IsAccel (HACCEL hac)
{
    PACCELTABLE pAcc = (PACCELTABLE)hac;

    if (pAcc->class != TYPE_HACCEL) return 0;

    return TRUE;
}

int GUIAPI DestroyAcceleratorTable (HACCEL hacc)
{
    PACCELTABLE pac;
    PACCELITEM pai, ptmpai;

    pac = (PACCELTABLE) hacc;

    if (pac->class != TYPE_HACCEL)
        return ERR_INVALID_HANDLE;
    
    
    pai = pac->head;
    while (pai) {
            ptmpai = pai->next;
            FreeAccelItem (pai);
            pai = ptmpai;
        }

     FreeAccelTable (pac);
    return 0;
}

PACCELITEM *accFindMatchAccelKeys(HACCEL hacc, int key,DWORD keymask )
{
    PACCELITEM  pai;
    PACCELTABLE pacc = (PACCELTABLE) hacc;
    pai = pacc -> head;
    if (pai)
    {
       if (pai -> key == key && pai -> keymask == keymask) 
           return &(pacc->head);
       else while (pai -> next)
       {
	  if (pai -> next ->key == key && pai -> next -> keymask == keymask)
	       return &(pai->next) ;
	  pai = pai ->next;
       }
     }
     return NULL;
}
 
int GUIAPI AddAccelerators (HACCEL hacc, int key,DWORD keymask, WPARAM wParam , LPARAM lParam)
{
    PACCELTABLE pac;
    PACCELITEM pnewai;

    pac = (PACCELTABLE) hacc;

    if (pac->class != TYPE_HACCEL)
        return ERR_INVALID_HANDLE; 
    if (accFindMatchAccelKeys(hacc,key,mergeKeymask(keymask)))
       return  ERR_ALREADY_EXIST;
    if (!(pnewai = AccelItemAlloc ())) 
        return ERR_RES_ALLOCATION;

    pnewai->key             = key;
    pnewai->keymask         = mergeKeymask (keymask);
    pnewai->wParam	    = wParam;  
    pnewai->lParam	    = lParam;
    pnewai->next = pac    -> head ;
    pac -> head  = pnewai ;
    return 0;
}

int DeleteAccelerators(HACCEL hacc,int key, DWORD keymask) // key has the same meaning in accelitem struct
{
    PACCELTABLE pac;
    PACCELITEM *ptempac;
    PACCELITEM ptempac1;
    pac = (PACCELTABLE) hacc;
    if (pac -> class != TYPE_HACCEL)
	return ERR_INVALID_HANDLE;
    if (!(ptempac=accFindMatchAccelKeys(hacc,key, mergeKeymask(keymask))))
	return ERR_NO_MATCH;
    ptempac1= ((*ptempac)->next);
    FreeAccelItem(*ptempac);
    (*ptempac) = ptempac1; 
    return 0;  
}

HACCEL CopyAcceleratorTable(HACCEL hacc)
{
	HACCEL hac;
	PACCELTABLE pac = (PACCELTABLE)hacc;
	PACCELITEM pai;
	if ((hac = (HACCEL) CreateAcceleratorTable(pac->hwnd)))
	{
		pai = pac -> head;
		while (pai)
		{
			if (AddAccelerators(hac,pai->key,pai->keymask,pai->wParam,pai->lParam)!=0)
			   {
			   	  DestroyAcceleratorTable(hac);
			   	  return (HACCEL) NULL;
			   }
			pai = pai -> next;
			
		}
		return hac;
		
	}
	else return (HACCEL) NULL; 
}

int GUIAPI TranslateAccelerator(HWND hWnd, HACCEL hAccel, PMSG pMsg)
{
   PACCELTABLE pac;
   PACCELITEM  *pai;
   int key;
   pac = (PACCELTABLE) hAccel;

   if (pac -> hwnd != hWnd)
      return ERR_BAD_OWNER;

   if ( pMsg->message == MSG_KEYDOWN || pMsg->message == MSG_SYSKEYDOWN)
       key = pMsg -> wParam | 256 ;
   else  if ( pMsg->message == MSG_CHAR || pMsg->message == MSG_SYSCHAR)
             key = pMsg -> wParam & 255;
   else 
       return FALSE;

   if ((pai=accFindMatchAccelKeys(hAccel,key, mergeKeymask(pMsg -> lParam))))
   {
       if (pMsg -> message == MSG_SYSKEYDOWN || pMsg -> message == MSG_SYSCHAR)
           return  SendNotifyMessage(hWnd,
                    MSG_SYSCOMMAND, (*pai) -> wParam, (*pai) -> lParam);
       else 
           return SendNotifyMessage(hWnd, 
                    MSG_COMMAND, (*pai) -> wParam , (*pai) -> lParam);
   }
   else 
        return FALSE;
}