i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Fixed Canna (and bug #3660) for real this time.

Browse Source 
* Cleaned up CannaLooper.cpp/h to mostly conform to our coding style.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29897 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2009-04-04 13:35:46 +00:00
parent ded432494c
commit 4f4312b1c7
4 changed files with 377 additions and 436 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build/jam/HaikuImage
+9 -9
View File
@@ -344,16 +344,16 @@ local ttFonts = [ Glob $(fontDir)/ttfonts : *.ttf ] ;
AddFilesToHaikuImage system fonts psfonts : $(psFonts) ; AddFilesToHaikuImage system fonts psfonts : $(psFonts) ;
AddFilesToHaikuImage system fonts ttfonts : $(ttFonts) ; AddFilesToHaikuImage system fonts ttfonts : $(ttFonts) ;
local kanbeDir = [ FDirName $(HAIKU_TOP) data etc KanBe ] ; local cannaDir = [ FDirName $(HAIKU_TOP) data etc KanBe ] ;
local kanbeDefault = [ Glob $(kanbeDir)/default : *.canna *.gz ] ; local cannaDefault = [ Glob $(cannaDir)/default : *.canna *.gz ] ;
local kanbeDic = [ Glob $(kanbeDir)/dic : *.cbp ] ; local cannaDic = [ Glob $(cannaDir)/dic : *.cbp ] ;
local kanbeDicCanna = [ Glob $(kanbeDir)/dic/canna local cannaDicCanna = [ Glob $(cannaDir)/dic/canna
: *.cld *.ctd *.cbd *.dir ] ; : *.cld *.ctd *.cbd *.dir ] ;
AddFilesToHaikuImage system data KanBe default : $(kanbeDefault) ; AddFilesToHaikuImage system data Canna default : $(cannaDefault) ;
AddFilesToHaikuImage system data KanBe dic : $(kanbeDic) ; AddFilesToHaikuImage system data Canna dic : $(cannaDic) ;
AddFilesToHaikuImage system data KanBe dic canna : $(kanbeDicCanna) ; AddFilesToHaikuImage system data Canna dic canna : $(cannaDicCanna) ;
AddDirectoryToHaikuImage system data KanBe dic group ; AddDirectoryToHaikuImage system data Canna dic group ;
AddDirectoryToHaikuImage system data KanBe dic user ; AddDirectoryToHaikuImage system data Canna dic user ;
local keymapFiles = [ GLOB [ FDirName $(HAIKU_TOP) src data etc keymaps ] local keymapFiles = [ GLOB [ FDirName $(HAIKU_TOP) src data etc keymaps ]
: *.keymap ] ; : *.keymap ] ;
src/add-ons/input_server/methods/canna/CannaLooper.cpp
+307 -367
View File
@@ -1,15 +1,17 @@
// /*
// CannaLooper.cpp * Copyright 2007-2009 Haiku Inc. All rights reserved.
// CannaIM looper object * Distributed under the terms of the MIT License.
*
* Copyright 1999 M.Kawamura
*/
// This is a part of...
// CannaIM #include "CannaLooper.h"
// version 1.0
// (c) 1999 M.Kawamura
//
#include <string.h> #include <string.h>
#include <Debug.h>
#include <Alert.h> #include <Alert.h>
#include <FindDirectory.h> #include <FindDirectory.h>
#include <Input.h> #include <Input.h>
@@ -19,96 +21,75 @@
#include <Path.h> #include <Path.h>
#include <Screen.h> #include <Screen.h>
#ifdef DEBUG
# include <Debug.h>
#endif
#include "CannaCommon.h" #include "CannaCommon.h"
#include "CannaLooper.h"
#include "CannaMethod.h" #include "CannaMethod.h"
#include "KouhoWindow.h" #include "KouhoWindow.h"
#include "PaletteWindow.h" #include "PaletteWindow.h"
CannaLooper::CannaLooper(CannaMethod* method) CannaLooper::CannaLooper(CannaMethod* method)
: BLooper("Canna Looper") : BLooper("Canna Looper"),
fOwner(method),
fCanna(NULL),
fKouhoWindow(NULL),
fPaletteWindow(NULL)
{ {
owner = method; fMenu = new BMenu(B_EMPTY_STRING);
canna = 0; fMenu->SetFont(be_plain_font);
theKouhoWindow = 0; fMenu->AddItem(new BMenuItem("About CannaIM" B_UTF8_ELLIPSIS,
thePalette = 0; new BMessage( B_ABOUT_REQUESTED)));
self = BMessenger( NULL, this ); fMenu->AddSeparatorItem();
fMenu->AddItem(new BMenuItem("Convert arrow keys",
new BMessage(ARROW_KEYS_FLIPPED)));
fMenu->AddItem(new BMenuItem("Reload Init file",
new BMessage(RELOAD_INIT_FILE)));
theMenu = new BMenu( B_EMPTY_STRING ); if (gSettings.convert_arrowkey) {
theMenu->SetFont( be_plain_font ); BMenuItem* item = fMenu->FindItem(ARROW_KEYS_FLIPPED);
theMenu->AddItem( new BMenuItem( "About CannaIM" B_UTF8_ELLIPSIS, new BMessage( B_ABOUT_REQUESTED ))); item->SetMarked(true);
theMenu->AddSeparatorItem();
theMenu->AddItem( new BMenuItem( "Convert arrow keys", new BMessage( ARROW_KEYS_FLIPPED )));
theMenu->AddItem( new BMenuItem( "Reload Init file", new BMessage( RELOAD_INIT_FILE )));
if ( gSettings.convert_arrowkey )
{
BMenuItem *item = theMenu->FindItem( ARROW_KEYS_FLIPPED );
item->SetMarked( true );
} }
Run(); Run();
} }
status_t status_t
CannaLooper::InitCheck() CannaLooper::Init()
{ {
status_t err; char basePath[B_PATH_NAME_LENGTH + 1];
char basepath[ B_PATH_NAME_LENGTH + 1 ]; status_t err = ReadSettings(basePath);
err = ReadSettings( basepath ); if (err != B_NO_ERROR)
if ( err != B_NO_ERROR )
return err; return err;
canna = new CannaInterface( basepath ); fCanna = new CannaInterface(basePath);
err = canna->InitCheck();
if ( err != B_NO_ERROR )
return err;
// theKouhoWindow = new KouhoWindow( &kouhoFont ); return fCanna->InitCheck();
return B_NO_ERROR;
} }
void void
CannaLooper::Quit() CannaLooper::Quit()
{ {
// delete palette here // delete palette here
#ifdef DEBUG SERIAL_PRINT(("CannaLooper: destructor called.\n"));
SERIAL_PRINT(( "CannaLooper: destructor called.\n" )); delete fCanna;
#endif
if ( canna ) if (fKouhoWindow != NULL) {
{ SERIAL_PRINT(("CannaLooper: Sending QUIT to kouho window...\n"));
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: Deleting canna...\n" )); fKouhoWindow->Lock();
#endif fKouhoWindow->Quit();
delete canna;
} }
if ( theKouhoWindow ) if (fPaletteWindow) {
{ SERIAL_PRINT(("CannaLooper: Sending QUIT to palette...\n"));
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: Sending QUIT to kouho window...\n" )); fPaletteWindow->Lock();
#endif fPaletteWindow->Quit();
theKouhoWindow->Lock();
theKouhoWindow->Quit();
} }
if ( thePalette ) fOwner->SetMenu(NULL, BMessenger());
{ delete fMenu;
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: Sending QUIT to palette...\n" ));
#endif
thePalette->Lock();
thePalette->Quit();
}
owner->SetMenu( NULL, BMessenger() );
delete theMenu;
BLooper::Quit(); BLooper::Quit();
} }
@@ -121,431 +102,390 @@ CannaLooper::ReadSettings(char* basePath)
if (status != B_OK) if (status != B_OK)
return status; return status;
path.Append("KanBe"); path.Append("Canna");
strcpy(basePath, path.Path()); strlcpy(basePath, path.Path(), B_PATH_NAME_LENGTH);
strlcat(basePath, "/", B_PATH_NAME_LENGTH);
font_family family; font_family family;
font_style style; font_style style;
strcpy(family, "Haru"); strcpy(family, "Haru");
strcpy(style, "Regular"); strcpy(style, "Regular");
kouhoFont.SetFamilyAndStyle(family, style); fKouhoFont.SetFamilyAndStyle(family, style);
kouhoFont.SetSize(12); fKouhoFont.SetSize(12);
return B_OK; return B_OK;
} }
void void
CannaLooper::EnqueueMessage( BMessage *msg ) CannaLooper::EnqueueMessage(BMessage* msg)
{ {
owner->EnqueueMessage( msg ); fOwner->EnqueueMessage(msg);
} }
void void
CannaLooper::MessageReceived( BMessage *msg ) CannaLooper::MessageReceived(BMessage* msg)
{ {
#ifdef DEBUG SERIAL_PRINT(("CannaLooper: Entering MessageReceived() what=%.4s\n",
SERIAL_PRINT(( "CannaLooper: Entering MessageReceived() what=%x\n", msg->what )); (char*)&msg->what));
#endif
switch ( msg->what ) switch (msg->what) {
{
case B_KEY_DOWN: case B_KEY_DOWN:
case NUM_SELECTED_FROM_KOUHO_WIN: case NUM_SELECTED_FROM_KOUHO_WIN:
HandleKeyDown( msg ); _HandleKeyDown(msg);
break; break;
case B_INPUT_METHOD_EVENT: case B_INPUT_METHOD_EVENT:
uint32 opcode, result; uint32 opcode, result;
opcode = 0; msg->FindInt32("be:opcode", (int32*)&opcode);
msg->FindInt32( "be:opcode", (int32 *)&opcode );
switch ( opcode ) switch (opcode) {
{
case B_INPUT_METHOD_LOCATION_REQUEST: case B_INPUT_METHOD_LOCATION_REQUEST:
HandleLocationReply( msg ); _HandleLocationReply(msg);
break; break;
case B_INPUT_METHOD_STOPPED: case B_INPUT_METHOD_STOPPED:
#ifdef DEBUG SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_STOPPED "
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_STOPPED received\n" )); "received\n"));
#endif _ForceKakutei();
ForceKakutei();
break; break;
} }
break; break;
case CANNA_METHOD_ACTIVATED: case CANNA_METHOD_ACTIVATED:
#ifdef DEBUG SERIAL_PRINT(("CannaLooper: CANNA_METHOD_ACTIVATED received\n"));
SERIAL_PRINT(( "CannaLooper: CANNA_METHOD_ACTIVATED received\n" )); _HandleMethodActivated(msg->HasBool("active"));
#endif
HandleMethodActivated( msg->HasBool( "active" ) );
break; break;
case MODE_CHANGED_FROM_PALETTE: case MODE_CHANGED_FROM_PALETTE:
ForceKakutei(); _ForceKakutei();
int32 mode; int32 mode;
msg->FindInt32( "mode", &mode ); msg->FindInt32("mode", &mode);
result = canna->ChangeMode( mode ); result = fCanna->ChangeMode(mode);
ProcessResult( result ); _ProcessResult(result);
break; break;
case B_ABOUT_REQUESTED: case B_ABOUT_REQUESTED:
#ifdef DEBUG {
SERIAL_PRINT(( "CannaLooper: B_ABOUT_REQUESTED received\n" )); SERIAL_PRINT(("CannaLooper: B_ABOUT_REQUESTED received\n"));
#endif
BAlert *panel; BAlert* panel = new BAlert( "", "Canna Input Method\n"
panel = new BAlert( "", "CannaIM Version 1.02\n" " by Masao Kawamura 1999\n\n"
" by Masao Kawamura 1999\n\n" "Canna\n"
"Canna\n Copyright 1992 NEC Corporation, Tokyo, Japan\n" " Copyright 1992 NEC Corporation, Tokyo, Japan\n"
" Special thanks to T.Murai for porting\n" " Special thanks to T.Murai for porting\n",
" BeOS Version 1.02", "OK");
"OK" );
panel->Go(); panel->Go();
break; break;
}
case RELOAD_INIT_FILE: case RELOAD_INIT_FILE:
ForceKakutei(); _ForceKakutei();
canna->Reset(); fCanna->Reset();
break; break;
case ARROW_KEYS_FLIPPED: case ARROW_KEYS_FLIPPED:
{ {
BMenuItem *item = theMenu->FindItem( ARROW_KEYS_FLIPPED ); BMenuItem* item = fMenu->FindItem(ARROW_KEYS_FLIPPED);
gSettings.convert_arrowkey = !gSettings.convert_arrowkey; gSettings.convert_arrowkey = !gSettings.convert_arrowkey;
item->SetMarked( gSettings.convert_arrowkey ); item->SetMarked(gSettings.convert_arrowkey);
canna->SetConvertArrowKey( gSettings.convert_arrowkey ); fCanna->SetConvertArrowKey(gSettings.convert_arrowkey);
}
break; break;
}
default: default:
BLooper::MessageReceived( msg ); BLooper::MessageReceived(msg);
break; break;
} }
} }
void CannaLooper::HandleKeyDown( BMessage *msg )
{
uint32 result;
uint32 modifier;
// int32 rawchar;
int32 key;
char theChar;
msg->FindInt32( "modifiers", (int32 *)&modifier );
msg->FindInt32( "key", &key );
// msg->FindInt32( "raw_char", &rawchar );
if ( ( modifier & B_COMMAND_KEY ) != 0 )
{
EnqueueMessage( DetachCurrentMessage() );
return;
}
msg->FindInt8( "byte", (int8 *)&theChar );
// The if clause below is to avoid processing key input which char code is 0x80 or more.
// if mikakutei string exists, dispose current message.
// Otherwise, send it to application as usual B_KEY_DOWN message.
// This is a bug fix for version 1.0 beta 2
if ( theChar & 0x80 )
{
if ( canna->MikakuteiLength() != 0 )
{
BMessage *blackhole = DetachCurrentMessage();
delete blackhole;
}
else
EnqueueMessage( DetachCurrentMessage() );
return;
}
// end of bug fix
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: HandleKeyDown() calling CannaInterface::KeyIn()...\n", result ));
#endif
result = canna->KeyIn( theChar, modifier, key );
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: HandleKeyDown() received result = %d from CannaInterface.\n", result ));
#endif
ProcessResult( result );
}
void void
CannaLooper::ProcessResult( uint32 result ) CannaLooper::_HandleKeyDown(BMessage* msg)
{ {
#ifdef DEBUG uint32 modifier;
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing result = %d\n", result )); int32 key;
#endif msg->FindInt32("modifiers", (int32*)&modifier);
if ( result & GUIDELINE_APPEARED ) msg->FindInt32("key", &key);
{
#ifdef DEBUG if ((modifier & B_COMMAND_KEY) != 0) {
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing GUIDELINE_APPEARED\n" )); EnqueueMessage(DetachCurrentMessage());
#endif return;
if ( canna->MikakuteiLength() != 0 ) // usual guideline i.e. kouho }
{
BMessage *msg = new BMessage( B_INPUT_METHOD_EVENT ); char character;
msg->AddInt32( "be:opcode", B_INPUT_METHOD_LOCATION_REQUEST ); msg->FindInt8("byte", (int8*)&character);
owner->EnqueueMessage( msg );
#ifdef DEBUG // The if clause below is to avoid processing key input which char code
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST has been sent\n" )); // is 0x80 or more.
#endif // if mikakutei string exists, dispose current message.
// Otherwise, send it to application as usual B_KEY_DOWN message.
if ((character & 0x80) != 0) {
if (fCanna->MikakuteiLength() != 0)
delete DetachCurrentMessage();
else
EnqueueMessage(DetachCurrentMessage());
return;
}
SERIAL_PRINT(("CannaLooper: HandleKeyDown() calling "
"CannaInterface::KeyIn()...\n", result));
uint32 result = fCanna->KeyIn(character, modifier, key);
SERIAL_PRINT(("CannaLooper: HandleKeyDown() received result = %d from "
"CannaInterface.\n", result));
_ProcessResult(result);
}
void
CannaLooper::_ProcessResult(uint32 result)
{
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing result = %d\n",
result));
if ((result & GUIDELINE_APPEARED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"GUIDELINE_APPEARED\n"));
if (fCanna->MikakuteiLength() != 0) {
// usual guideline i.e. kouho
BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_LOCATION_REQUEST);
fOwner->EnqueueMessage(msg);
SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST has "
"been sent\n"));
} else {
// guideline exists, but no mikakutei string - means extend mode
// and such.
SERIAL_PRINT((" GUIDELINE_APPEARED: calling "
"GenerateKouho()...\n"));
fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
SERIAL_PRINT((" GUIDELINE_APPEARED: posting KouhoMsg to "
"KouhoWindow %x...\n", fKouhoWindow));
fKouhoWindow->PostMessage(KOUHO_WINDOW_SHOW_ALONE);
} }
else // guideline exists, but no mikakutei string - means extend mode and such.
{
#ifdef DEBUG
SERIAL_PRINT(( " GUIDELINE_APPEARED: calling GenerateKouho()...\n" ));
#endif
theKouhoWindow->PostMessage( canna->GenerateKouhoString() );
BMessage m( KOUHO_WINDOW_SHOW_ALONE );
#ifdef DEBUG
SERIAL_PRINT(( " GUIDELINE_APPEARED: posting KouhoMsg to KouhoWindow %x...\n", theKouhoWindow ));
#endif
theKouhoWindow->PostMessage( &m );
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: KOUHO_WINDOW_SHOW_ALONE has been sent\n" ));
#endif
}
} }
// if ( result == MIKAKUTEI_NO_CHANGE ) if ((result & GUIDELINE_DISAPPEARED) != 0) {
// return; SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"GUIDELINE_DISAPPEARED\n"));
if ( result & GUIDELINE_DISAPPEARED ) fKouhoWindow->PostMessage(KOUHO_WINDOW_HIDE);
{
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing GUIDELINE_DISAPPEARED\n" ));
#endif
theKouhoWindow->PostMessage( KOUHO_WINDOW_HIDE );
} }
if ( result & MODE_CHANGED ) if ((result & MODE_CHANGED) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "MODE_CHANGED\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing MODE_CHANGED\n" ));
#endif BMessage message(PALETTE_WINDOW_BUTTON_UPDATE);
int32 mode; message.AddInt32("mode", fCanna->GetMode());
mode = canna->GetMode(); fPaletteWindow->PostMessage(&message);
BMessage m( PALETTE_WINDOW_BUTTON_UPDATE );
m.AddInt32( "mode", mode ); SERIAL_PRINT(("CannaLooper: PALETTE_BUTTON_UPDATE has been sent. "
thePalette->PostMessage( &m ); "mode = %d\n", fCanna->GetMode()));
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: PALETTE_BUTTON_UPDATE has been sent. mode = %d\n", mode ));
#endif
} }
if ( result & GUIDELINE_CHANGED ) if ((result & GUIDELINE_CHANGED) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "GUIDELINE_CHANGED\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing GUIDELINE_CHANGED\n" )); fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
#endif
theKouhoWindow->PostMessage( canna->GenerateKouhoString() );
} }
if ( result & THROUGH_INPUT ) if ((result & THROUGH_INPUT) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "THROUGH_INPUT\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing THROUGH_INPUT\n" )); EnqueueMessage(DetachCurrentMessage());
#endif
EnqueueMessage( DetachCurrentMessage() );
} }
if ( result & NEW_INPUT_STARTED ) if ((result & NEW_INPUT_STARTED) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "NEW_INPUT_STARTED\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing NEW_INPUT_STARTED\n" ));
#endif
SendInputStarted(); SendInputStarted();
} }
if ( result & KAKUTEI_EXISTS ) if ((result & KAKUTEI_EXISTS) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "KAKUTEI_EXISTS\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing KAKUTEI_EXISTS\n" ));
#endif
BMessage *msg = new BMessage( B_INPUT_METHOD_EVENT );
msg->AddInt32( "be:opcode", B_INPUT_METHOD_CHANGED );
msg->AddString("be:string", canna->GetKakuteiStr() ); BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_CHANGED);
msg->AddString("be:string", fCanna->GetKakuteiStr());
msg->AddInt32("be:clause_start", 0); msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", canna->KakuteiLength() ); msg->AddInt32("be:clause_end", fCanna->KakuteiLength());
msg->AddInt32("be:selection", canna->KakuteiLength() ); msg->AddInt32("be:selection", fCanna->KakuteiLength());
msg->AddInt32("be:selection", canna->KakuteiLength() ); msg->AddInt32("be:selection", fCanna->KakuteiLength());
msg->AddBool( "be:confirmed", true ); msg->AddBool("be:confirmed", true);
owner->EnqueueMessage( msg ); fOwner->EnqueueMessage(msg);
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_CHANGED (confired) has been sent\n" )); SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_CHANGED (confired) has "
#endif "been sent\n"));
if ( !(result & MIKAKUTEI_EXISTS) ) //if both kakutei and mikakutei exist, do not send B_INPUT_STOPPED
// if both kakutei and mikakutei exist, do not send B_INPUT_STOPPED
if (!(result & MIKAKUTEI_EXISTS))
SendInputStopped(); SendInputStopped();
} }
if ( result & MIKAKUTEI_EXISTS ) if ((result & MIKAKUTEI_EXISTS) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "MIKAKUTEI_EXISTS\n" ));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing MIKAKUTEI_EXISTS\n" ));
#endif
int32 start, finish; int32 start, finish;
BMessage *msg = new BMessage( B_INPUT_METHOD_EVENT ); BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32( "be:opcode", B_INPUT_METHOD_CHANGED ); msg->AddInt32("be:opcode", B_INPUT_METHOD_CHANGED);
msg->AddString("be:string", fCanna->GetMikakuteiStr());
msg->AddString("be:string", canna->GetMikakuteiStr() ); if (fCanna->HasRev()) {
if ( canna->HasRev() ) fCanna->GetRevPosition( &start, &finish);
{
canna->GetRevPosition( &start, &finish );
msg->AddInt32("be:clause_start", 0); msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", start ); msg->AddInt32("be:clause_end", start);
msg->AddInt32("be:clause_start", start ); msg->AddInt32("be:clause_start", start);
msg->AddInt32("be:clause_end", finish ); msg->AddInt32("be:clause_end", finish);
msg->AddInt32("be:clause_start", finish ); msg->AddInt32("be:clause_start", finish);
msg->AddInt32("be:clause_end", canna->MikakuteiLength() ); msg->AddInt32("be:clause_end", fCanna->MikakuteiLength());
} } else {
else start = finish = fCanna->MikakuteiLength();
{
start = finish = canna->MikakuteiLength();
msg->AddInt32("be:clause_start", 0); msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", canna->MikakuteiLength() ); msg->AddInt32("be:clause_end", fCanna->MikakuteiLength());
} }
msg->AddInt32("be:selection", start ); msg->AddInt32("be:selection", start);
msg->AddInt32("be:selection", finish ); msg->AddInt32("be:selection", finish);
//msg->AddBool( "be:confirmed", false ); //msg->AddBool("be:confirmed", false);
owner->EnqueueMessage( msg ); fOwner->EnqueueMessage(msg);
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_CHANGED (non-confirmed) has been sent\n" )); SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_CHANGED (non-confirmed) "
#endif "has been sent\n"));
} }
if ( result & MIKAKUTEI_BECOME_EMPTY ) if ((result & MIKAKUTEI_BECOME_EMPTY) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "MIKAKUTEI_BECOME_EMPTY\n" ));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing MIKAKUTEI_BECOME_EMPTY\n" )); BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
#endif msg->AddInt32("be:opcode", B_INPUT_METHOD_CHANGED);
BMessage *msg = new BMessage( B_INPUT_METHOD_EVENT );
msg->AddInt32( "be:opcode", B_INPUT_METHOD_CHANGED );
msg->AddString("be:string", B_EMPTY_STRING ); msg->AddString("be:string", B_EMPTY_STRING);
msg->AddInt32("be:clause_start", 0); msg->AddInt32("be:clause_start", 0);
msg->AddInt32("be:clause_end", 0 ); msg->AddInt32("be:clause_end", 0);
msg->AddInt32("be:selection", 0 ); msg->AddInt32("be:selection", 0);
msg->AddInt32("be:selection", 0 ); msg->AddInt32("be:selection", 0);
msg->AddBool( "be:confirmed", true ); msg->AddBool( "be:confirmed", true);
owner->EnqueueMessage( msg ); fOwner->EnqueueMessage(msg);
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_CHANGED (NULL, confired) has been sent\n" )); SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_CHANGED (NULL, confired) "
#endif "has been sent\n"));
SendInputStopped(); SendInputStopped();
} }
} }
void void
CannaLooper::HandleLocationReply( BMessage *msg ) CannaLooper::_HandleLocationReply(BMessage* msg)
{ {
BPoint where = B_ORIGIN; BPoint where = B_ORIGIN;
float height = 0.0; float height = 0.0;
int32 start; int32 start;
#ifdef DEBUG SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST received\n"));
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST received\n" ));
#endif start = fCanna->GetRevStartPositionInChar();
start = canna->GetRevStartPositionInChar();
#ifdef DEBUG #ifdef DEBUG
type_code type; type_code type;
int32 count; int32 count;
msg->GetInfo( "be:location_reply", &type, &count ); msg->GetInfo("be:location_reply", &type, &count);
SERIAL_PRINT(( "CannaLooper: LOCATION_REPLY has %d locations.\n", count )); SERIAL_PRINT(("CannaLooper: LOCATION_REPLY has %d locations.\n", count));
SERIAL_PRINT(( "CannaLooper: RevStartPosition is %d.\n", start )); SERIAL_PRINT(("CannaLooper: RevStartPosition is %d.\n", start));
#endif #endif
msg->FindPoint( "be:location_reply", start, &where );
msg->FindFloat( "be:height_reply", start, &height );
BMessage m( KOUHO_WINDOW_SHOWAT );
m.AddPoint( "position", where );
m.AddFloat( "height", height );
msg->FindPoint("be:location_reply", start, &where);
msg->FindFloat("be:height_reply", start, &height);
BMessage m(KOUHO_WINDOW_SHOWAT);
m.AddPoint("position", where);
m.AddFloat("height", height);
theKouhoWindow->PostMessage( canna->GenerateKouhoString() ); fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
theKouhoWindow->PostMessage( &m ); fKouhoWindow->PostMessage(&m);
} }
void void
CannaLooper::HandleMethodActivated( bool active ) CannaLooper::_HandleMethodActivated(bool active)
{ {
if ( active ) if (active) {
{ if (!fPaletteWindow) {
if ( !thePalette ) //first time input method activated // first time input method activated
{
float x = gSettings.palette_loc.x; float x = gSettings.palette_loc.x;
float y = gSettings.palette_loc.y; float y = gSettings.palette_loc.y;
BRect frame( x, y, x + 114, y + 44 ); BRect frame(x, y, x + 114, y + 44);
thePalette = new PaletteWindow( frame, this ); fPaletteWindow = new PaletteWindow(frame, this);
thePalette->Show(); fPaletteWindow->Show();
theKouhoWindow = new KouhoWindow( &kouhoFont, this ); fKouhoWindow = new KouhoWindow(&fKouhoFont, this);
theKouhoWindow->Run(); fKouhoWindow->Run();
} }
thePalette->PostMessage( PALETTE_WINDOW_SHOW );
owner->SetMenu( theMenu, self ); fPaletteWindow->PostMessage(PALETTE_WINDOW_SHOW);
} fOwner->SetMenu(fMenu, this);
else } else {
{ _ForceKakutei();
ForceKakutei(); fCanna->ChangeMode(CANNA_MODE_HenkanMode);
canna->ChangeMode( CANNA_MODE_HenkanMode ); BMessage m(PALETTE_WINDOW_BUTTON_UPDATE);
BMessage m( PALETTE_WINDOW_BUTTON_UPDATE ); m.AddInt32("mode", CANNA_MODE_HenkanMode);
m.AddInt32( "mode", CANNA_MODE_HenkanMode ); fPaletteWindow->PostMessage(&m);
thePalette->PostMessage( &m ); fPaletteWindow->PostMessage(PALETTE_WINDOW_HIDE);
thePalette->PostMessage( PALETTE_WINDOW_HIDE ); fKouhoWindow->PostMessage(KOUHO_WINDOW_HIDE);
theKouhoWindow->PostMessage( KOUHO_WINDOW_HIDE ); fOwner->SetMenu(NULL, this);
owner->SetMenu( NULL, self );
} }
} }
void void
CannaLooper::ForceKakutei() CannaLooper::_ForceKakutei()
{ {
#ifdef DEBUG SERIAL_PRINT(( "CannaLooper: _ForceKakutei() called\n" ));
SERIAL_PRINT(( "CannaLooper: ForceKakutei() called\n" ));
#endif uint32 result = fCanna->Kakutei();
uint32 result = canna->Kakutei();
#ifdef DEBUG SERIAL_PRINT(("CannaLooper: returned from Kakutei(). result = %d\n",
SERIAL_PRINT(( "CannaLooper: returned from Kakutei(). result = %d\n", result )); result));
#endif
if ( result != NOTHING_TO_KAKUTEI ) if (result != NOTHING_TO_KAKUTEI)
ProcessResult( result ); _ProcessResult(result);
else else
SendInputStopped(); SendInputStopped();
return;
} }
void void
CannaLooper::SendInputStopped() CannaLooper::SendInputStopped()
{ {
BMessage *msg = new BMessage( B_INPUT_METHOD_EVENT ); BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32( "be:opcode", B_INPUT_METHOD_STOPPED ); msg->AddInt32("be:opcode", B_INPUT_METHOD_STOPPED);
EnqueueMessage( msg ); EnqueueMessage(msg);
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_STOPPED has been sent\n" )); SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_STOPPED has been sent\n"));
#endif
} }
void void
CannaLooper::SendInputStarted() CannaLooper::SendInputStarted()
{ {
BMessage *msg = new BMessage( B_INPUT_METHOD_EVENT ); BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32( "be:opcode", B_INPUT_METHOD_STARTED ); msg->AddInt32("be:opcode", B_INPUT_METHOD_STARTED);
msg->AddMessenger( "be:reply_to", BMessenger( NULL, this ) ); msg->AddMessenger("be:reply_to", BMessenger(NULL, this));
EnqueueMessage( msg ); EnqueueMessage(msg);
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_STARTED has been sent\n" )); SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_STARTED has been sent\n"));
#endif
} }
src/add-ons/input_server/methods/canna/CannaLooper.h
+33 -35
View File
@@ -1,15 +1,12 @@
// /*
// CannaLooper.h * Copyright 2007-2009 Haiku Inc. All rights reserved.
// CannaIM Looper object * Distributed under the terms of the MIT License.
*
* Copyright 1999 M.Kawamura
*/
#ifndef CANNA_LOOPER_H
#define CANNA_LOOPER_H
// This is a part of...
// CannaIM
// version 1.0
// (c) 1999 M.Kawamura
//
#ifndef _CANNA_LOOPER_H
#define _CANNA_LOOPER_H
#include <Messenger.h> #include <Messenger.h>
#include <Font.h> #include <Font.h>
@@ -24,32 +21,33 @@ class BMessenger;
extern Preferences gSettings; extern Preferences gSettings;
class CannaLooper : public BLooper class CannaLooper : public BLooper {
{
public: public:
CannaLooper( CannaMethod *method ); CannaLooper(CannaMethod* method);
virtual void Quit();
void MessageReceived( BMessage *msg ); virtual void Quit();
void EnqueueMessage( BMessage *msg ); virtual void MessageReceived(BMessage* msg);
status_t InitCheck();
status_t ReadSettings( char *basepath ); void EnqueueMessage(BMessage* msg);
// bool QuitRequested(); status_t Init();
void SendInputStopped(); status_t ReadSettings(char* basePath);
void SendInputStarted();
void SendInputStopped();
void SendInputStarted();
private: private:
CannaMethod* owner; void _HandleKeyDown(BMessage* msg);
CannaInterface* canna; void _HandleLocationReply(BMessage* msg);
BFont kouhoFont; void _HandleMethodActivated(bool active);
void HandleKeyDown( BMessage *msg ); void _ProcessResult(uint32 result);
void HandleLocationReply( BMessage *msg ); void _ForceKakutei();
void HandleMethodActivated( bool active );
void ProcessResult( uint32 result ); CannaMethod* fOwner;
void ForceKakutei(); CannaInterface* fCanna;
KouhoWindow* theKouhoWindow; BFont fKouhoFont;
PaletteWindow* thePalette; KouhoWindow* fKouhoWindow;
BMenu* theMenu; PaletteWindow* fPaletteWindow;
BMessenger self; BMenu* fMenu;
}; };
#endif #endif // CANNA_LOOPER_H
src/add-ons/input_server/methods/canna/CannaMethod.cpp
+6 -3
View File
@@ -23,12 +23,15 @@ Preferences gSettings;
BInputServerMethod* BInputServerMethod*
instantiate_input_method() instantiate_input_method()
{ {
return (new CannaMethod()); return new CannaMethod();
} }
// #pragma mark -
CannaMethod::CannaMethod() CannaMethod::CannaMethod()
:BInputServerMethod( "Canna", (const uchar *)kCannaIcon ) : BInputServerMethod("Canna", (const uchar*)kCannaIcon)
{ {
#ifdef DEBUG #ifdef DEBUG
SERIAL_PRINT(( "CannaIM:Constructor called.\n" )); SERIAL_PRINT(( "CannaIM:Constructor called.\n" ));
@@ -87,7 +90,7 @@ CannaMethod::InitCheck()
status_t err; status_t err;
looper = new CannaLooper( this ); looper = new CannaLooper( this );
looper->Lock(); looper->Lock();
err = looper->InitCheck(); err = looper->Init();
looper->Unlock(); looper->Unlock();
cannaLooper = BMessenger( NULL, looper ); cannaLooper = BMessenger( NULL, looper );
#ifdef DEBUG #ifdef DEBUG