haiku.git

/*****************************************************************************/
// Haiku InputServer
//
// This is the InputServerMethod implementation
//
// This application and all source files used in its construction, except 
// where noted, are licensed under the MIT License, and have been written 
// and are:
//
// Copyright (c) 2002-2004 Haiku Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
// and/or sell copies of the Software, and to permit persons to whom the 
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included 
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/

#include <InputServerMethod.h>
#include <Menu.h>
#include <Messenger.h>
#include "InputServer.h"
#include "InputServerTypes.h"
#include "remote_icon.h"
/**
 *  Method: BInputServerMethod::BInputServerMethod()
 *   Descr: 
 */
BInputServerMethod::BInputServerMethod(const char *name,
                                       const uchar *icon)
{
	CALLED();
	fOwner = new _BMethodAddOn_(this, name, icon);
}


/**
 *  Method: BInputServerMethod::~BInputServerMethod()
 *   Descr: 
 */
BInputServerMethod::~BInputServerMethod()
{
	CALLED();
	delete fOwner;
}


/**
 *  Method: BInputServerMethod::MethodActivated()
 *   Descr: 
 */
status_t
BInputServerMethod::MethodActivated(bool active)
{
    return B_OK;
}


/**
 *  Method: BInputServerMethod::EnqueueMessage()
 *   Descr: 
 */
status_t
BInputServerMethod::EnqueueMessage(BMessage *message)
{
	return ((InputServer*)be_app)->EnqueueMethodMessage(message);
}


/**
 *  Method: BInputServerMethod::SetName()
 *   Descr: 
 */
status_t
BInputServerMethod::SetName(const char *name)
{
    return fOwner->SetName(name);
}


/**
 *  Method: BInputServerMethod::SetIcon()
 *   Descr: 
 */
status_t
BInputServerMethod::SetIcon(const uchar *icon)
{
    return fOwner->SetIcon(icon);
}


/**
 *  Method: BInputServerMethod::SetMenu()
 *   Descr: 
 */
status_t
BInputServerMethod::SetMenu(const BMenu *menu,
                            const BMessenger target)
{
    return fOwner->SetMenu(menu, target);
}


/**
 *  Method: BInputServerMethod::_ReservedInputServerMethod1()
 *   Descr: 
 */
void
BInputServerMethod::_ReservedInputServerMethod1()
{
}


/**
 *  Method: BInputServerMethod::_ReservedInputServerMethod2()
 *   Descr: 
 */
void
BInputServerMethod::_ReservedInputServerMethod2()
{
}


/**
 *  Method: BInputServerMethod::_ReservedInputServerMethod3()
 *   Descr: 
 */
void
BInputServerMethod::_ReservedInputServerMethod3()
{
}


/**
 *  Method: BInputServerMethod::_ReservedInputServerMethod4()
 *   Descr: 
 */
void
BInputServerMethod::_ReservedInputServerMethod4()
{
}


static int32 sNextMethodCookie = 1;


_BMethodAddOn_::_BMethodAddOn_(BInputServerMethod *method, const char *name,
	const uchar *icon)
	: fMethod(method),
	fMenu(NULL),
	fCookie(sNextMethodCookie++)
{
	fName = strdup(name);
	if (icon != NULL)
		memcpy(fIcon, icon, 16*16*1);
	else
		memset(fIcon, 0x1d, 16*16*1);
}


_BMethodAddOn_::~_BMethodAddOn_()
{
	free(fName);
	delete fMenu;
}


status_t
_BMethodAddOn_::SetName(const char* name)
{
	CALLED();
	if (fName)
		free(fName);
	if (name)
		fName = strdup(name);

	BMessage msg(IS_UPDATE_NAME);
	msg.AddInt32("cookie", fCookie);
	msg.AddString("name", name);
	if (((InputServer*)be_app)->MethodReplicant())
		return ((InputServer*)be_app)->MethodReplicant()->SendMessage(&msg);
	else
		return B_ERROR;
}


status_t
_BMethodAddOn_::SetIcon(const uchar* icon)
{	
	CALLED();

	if (icon != NULL)
		memcpy(fIcon, icon, 16*16*1);
	else
		memset(fIcon, 0x1d, 16*16*1);

	BMessage msg(IS_UPDATE_ICON);
	msg.AddInt32("cookie", fCookie);
	msg.AddData("icon", B_RAW_TYPE, icon, 16*16*1);
	if (((InputServer*)be_app)->MethodReplicant())
		return ((InputServer*)be_app)->MethodReplicant()->SendMessage(&msg);
	else
		return B_ERROR;
}


status_t
_BMethodAddOn_::SetMenu(const BMenu *menu, const BMessenger &messenger)
{
	CALLED();
	fMenu = menu;
	fMessenger = messenger;

	BMessage msg(IS_UPDATE_MENU);
	msg.AddInt32("cookie", fCookie);
	BMessage menuMsg;
	if (menu)
		menu->Archive(&menuMsg);
	msg.AddMessage("menu", &menuMsg);
	msg.AddMessenger("target", messenger);
	if (((InputServer*)be_app)->MethodReplicant())
		return ((InputServer*)be_app)->MethodReplicant()->SendMessage(&msg);
	else
		return B_ERROR;
}


status_t
_BMethodAddOn_::MethodActivated(bool activate)
{
	CALLED();
	if (fMethod) {
		PRINT(("%s cookie %" B_PRId32 "\n", __PRETTY_FUNCTION__, fCookie));
		if (activate && ((InputServer*)be_app)->MethodReplicant()) {
			BMessage msg(IS_UPDATE_METHOD);
        		msg.AddInt32("cookie", fCookie);
                	((InputServer*)be_app)->MethodReplicant()->SendMessage(&msg);
		}
		return fMethod->MethodActivated(activate);
	}
	return B_ERROR;
}


status_t
_BMethodAddOn_::AddMethod()
{
	PRINT(("%s cookie %" B_PRId32 "\n", __PRETTY_FUNCTION__, fCookie));
	BMessage msg(IS_ADD_METHOD);
	msg.AddInt32("cookie", fCookie);
	msg.AddString("name", fName);
	msg.AddData("icon", B_RAW_TYPE, fIcon, 16*16*1);
	BMessage menuMsg;
	if (fMenu != NULL)
		fMenu->Archive(&menuMsg);
	msg.AddMessage("menu", &menuMsg);
	msg.AddMessenger("target", fMessenger);
	if (((InputServer*)be_app)->MethodReplicant())
		return ((InputServer*)be_app)->MethodReplicant()->SendMessage(&msg);
	else
		return B_ERROR;
}


KeymapMethod::KeymapMethod()
        : BInputServerMethod("Roman", kRemoteBits)
{

}


KeymapMethod::~KeymapMethod()
{

}