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
+225 -285
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 )));
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); 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"));
#endif delete fCanna;
if ( canna )
{
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: Deleting canna...\n" ));
#endif
delete canna;
}
if ( theKouhoWindow ) if (fKouhoWindow != NULL) {
{
#ifdef DEBUG
SERIAL_PRINT(("CannaLooper: Sending QUIT to kouho window...\n")); SERIAL_PRINT(("CannaLooper: Sending QUIT to kouho window...\n"));
#endif
theKouhoWindow->Lock(); fKouhoWindow->Lock();
theKouhoWindow->Quit(); fKouhoWindow->Quit();
} }
if ( thePalette ) if (fPaletteWindow) {
{
#ifdef DEBUG
SERIAL_PRINT(("CannaLooper: Sending QUIT to palette...\n")); SERIAL_PRINT(("CannaLooper: Sending QUIT to palette...\n"));
#endif
thePalette->Lock(); fPaletteWindow->Lock();
thePalette->Quit(); fPaletteWindow->Quit();
} }
owner->SetMenu( NULL, BMessenger() ); fOwner->SetMenu(NULL, BMessenger());
delete theMenu; delete fMenu;
BLooper::Quit(); BLooper::Quit();
} }
@@ -121,17 +102,18 @@ 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;
} }
@@ -140,85 +122,79 @@ CannaLooper::ReadSettings(char* basePath)
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"));
#endif _HandleMethodActivated(msg->HasBool("active"));
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 Copyright 1992 NEC Corporation, Tokyo, Japan\n" "Canna\n"
" Special thanks to T.Murai for porting\n" " Copyright 1992 NEC Corporation, Tokyo, Japan\n"
" BeOS Version 1.02", " Special thanks to T.Murai for porting\n",
"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);
@@ -226,209 +202,175 @@ CannaLooper::MessageReceived( BMessage *msg )
} }
} }
void CannaLooper::HandleKeyDown( BMessage *msg )
{
uint32 result;
uint32 modifier;
// int32 rawchar;
int32 key;
char theChar;
void
CannaLooper::_HandleKeyDown(BMessage* msg)
{
uint32 modifier;
int32 key;
msg->FindInt32("modifiers", (int32*)&modifier); msg->FindInt32("modifiers", (int32*)&modifier);
msg->FindInt32("key", &key); msg->FindInt32("key", &key);
// msg->FindInt32( "raw_char", &rawchar );
if ( ( modifier & B_COMMAND_KEY ) != 0 ) if ((modifier & B_COMMAND_KEY) != 0) {
{
EnqueueMessage(DetachCurrentMessage()); EnqueueMessage(DetachCurrentMessage());
return; return;
} }
msg->FindInt8( "byte", (int8 *)&theChar ); char character;
msg->FindInt8("byte", (int8*)&character);
// The if clause below is to avoid processing key input which char code is 0x80 or more. // The if clause below is to avoid processing key input which char code
// is 0x80 or more.
// if mikakutei string exists, dispose current message. // if mikakutei string exists, dispose current message.
// Otherwise, send it to application as usual B_KEY_DOWN message. // Otherwise, send it to application as usual B_KEY_DOWN message.
// This is a bug fix for version 1.0 beta 2 if ((character & 0x80) != 0) {
if (fCanna->MikakuteiLength() != 0)
if ( theChar & 0x80 ) delete DetachCurrentMessage();
{
if ( canna->MikakuteiLength() != 0 )
{
BMessage *blackhole = DetachCurrentMessage();
delete blackhole;
}
else else
EnqueueMessage(DetachCurrentMessage()); EnqueueMessage(DetachCurrentMessage());
return; return;
} }
// end of bug fix SERIAL_PRINT(("CannaLooper: HandleKeyDown() calling "
"CannaInterface::KeyIn()...\n", result));
#ifdef DEBUG uint32 result = fCanna->KeyIn(character, modifier, key);
SERIAL_PRINT(( "CannaLooper: HandleKeyDown() calling CannaInterface::KeyIn()...\n", result ));
#endif
result = canna->KeyIn( theChar, modifier, key ); SERIAL_PRINT(("CannaLooper: HandleKeyDown() received result = %d from "
#ifdef DEBUG "CannaInterface.\n", result));
SERIAL_PRINT(( "CannaLooper: HandleKeyDown() received result = %d from CannaInterface.\n", result ));
#endif _ProcessResult(result);
ProcessResult( result );
} }
void void
CannaLooper::ProcessResult( uint32 result ) CannaLooper::_ProcessResult(uint32 result)
{
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing result = %d\n", result ));
#endif
if ( result & GUIDELINE_APPEARED )
{
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing GUIDELINE_APPEARED\n" ));
#endif
if ( canna->MikakuteiLength() != 0 ) // usual guideline i.e. kouho
{ {
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); BMessage* msg = new BMessage(B_INPUT_METHOD_EVENT);
msg->AddInt32("be:opcode", B_INPUT_METHOD_LOCATION_REQUEST); msg->AddInt32("be:opcode", B_INPUT_METHOD_LOCATION_REQUEST);
owner->EnqueueMessage( msg ); fOwner->EnqueueMessage(msg);
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST has been sent\n" )); SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_LOCATION_REQUEST has "
#endif "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 & GUIDELINE_DISAPPEARED) != 0) {
SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"GUIDELINE_DISAPPEARED\n"));
fKouhoWindow->PostMessage(KOUHO_WINDOW_HIDE);
} }
// if ( result == MIKAKUTEI_NO_CHANGE ) if ((result & MODE_CHANGED) != 0) {
// return; SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
"MODE_CHANGED\n"));
if ( result & GUIDELINE_DISAPPEARED ) BMessage message(PALETTE_WINDOW_BUTTON_UPDATE);
{ message.AddInt32("mode", fCanna->GetMode());
#ifdef DEBUG fPaletteWindow->PostMessage(&message);
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing GUIDELINE_DISAPPEARED\n" ));
#endif SERIAL_PRINT(("CannaLooper: PALETTE_BUTTON_UPDATE has been sent. "
theKouhoWindow->PostMessage( KOUHO_WINDOW_HIDE ); "mode = %d\n", fCanna->GetMode()));
} }
if ( result & MODE_CHANGED ) if ((result & GUIDELINE_CHANGED) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "GUIDELINE_CHANGED\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing MODE_CHANGED\n" )); fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
#endif
int32 mode;
mode = canna->GetMode();
BMessage m( PALETTE_WINDOW_BUTTON_UPDATE );
m.AddInt32( "mode", mode );
thePalette->PostMessage( &m );
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: PALETTE_BUTTON_UPDATE has been sent. mode = %d\n", mode ));
#endif
} }
if ( result & GUIDELINE_CHANGED ) if ((result & THROUGH_INPUT) != 0) {
{ SERIAL_PRINT(("CannaLooper: _ProcessResult() processing "
#ifdef DEBUG "THROUGH_INPUT\n"));
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing GUIDELINE_CHANGED\n" ));
#endif
theKouhoWindow->PostMessage( canna->GenerateKouhoString() );
}
if ( result & THROUGH_INPUT )
{
#ifdef DEBUG
SERIAL_PRINT(( "CannaLooper: ProcessResult() processing THROUGH_INPUT\n" ));
#endif
EnqueueMessage(DetachCurrentMessage()); 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); 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", canna->GetKakuteiStr() ); 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" ));
#endif
if ( !(result & MIKAKUTEI_EXISTS) ) //if both kakutei and mikakutei exist, do not send B_INPUT_STOPPED
SendInputStopped();
SERIAL_PRINT(("CannaLooper: B_INPUT_METHOD_CHANGED (confired) has "
"been sent\n"));
// if both kakutei and mikakutei exist, do not send B_INPUT_STOPPED
if (!(result & MIKAKUTEI_EXISTS))
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" ));
#endif
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);
@@ -438,27 +380,27 @@ CannaLooper::ProcessResult( uint32 result )
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 = canna->GetRevStartPositionInChar(); start = fCanna->GetRevStartPositionInChar();
#ifdef DEBUG #ifdef DEBUG
type_code type; type_code type;
int32 count; int32 count;
@@ -466,77 +408,76 @@ CannaLooper::HandleLocationReply( BMessage *msg )
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->FindPoint("be:location_reply", start, &where);
msg->FindFloat("be:height_reply", start, &height); msg->FindFloat("be:height_reply", start, &height);
BMessage m(KOUHO_WINDOW_SHOWAT); BMessage m(KOUHO_WINDOW_SHOWAT);
m.AddPoint("position", where); m.AddPoint("position", where);
m.AddFloat("height", height); m.AddFloat("height", height);
fKouhoWindow->PostMessage(fCanna->GenerateKouhoString());
theKouhoWindow->PostMessage( canna->GenerateKouhoString() ); fKouhoWindow->PostMessage(&m);
theKouhoWindow->PostMessage( &m );
} }
void void
CannaLooper::HandleMethodActivated( bool active ) CannaLooper::_HandleMethodActivated(bool active)
{
if ( active )
{
if ( !thePalette ) //first time input method activated
{ {
if (active) {
if (!fPaletteWindow) {
// 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);
thePalette->PostMessage( &m ); fPaletteWindow->PostMessage(&m);
thePalette->PostMessage( PALETTE_WINDOW_HIDE ); fPaletteWindow->PostMessage(PALETTE_WINDOW_HIDE);
theKouhoWindow->PostMessage( KOUHO_WINDOW_HIDE ); fKouhoWindow->PostMessage(KOUHO_WINDOW_HIDE);
owner->SetMenu( NULL, self ); fOwner->SetMenu(NULL, this);
} }
} }
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()
{ {
@@ -544,8 +485,7 @@ CannaLooper::SendInputStarted()
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
+28 -30
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(); virtual void Quit();
void MessageReceived( BMessage *msg ); virtual void MessageReceived(BMessage* msg);
void EnqueueMessage(BMessage* msg); void EnqueueMessage(BMessage* msg);
status_t InitCheck(); status_t Init();
status_t ReadSettings( char *basepath ); status_t ReadSettings(char* basePath);
// bool QuitRequested();
void SendInputStopped(); void SendInputStopped();
void SendInputStarted(); 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
+5 -2
View File
@@ -23,10 +23,13 @@ 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)
{ {
@@ -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