第7章 もっと動きを

#ifndef _CLOCKWORK_WAVE_APP_H_
#define _CLOCKWORK_WAVE_APP_H_

#include <app/Application.h>

/* 関連クラス・構造体 */
class	RegularWindow;
class	TimeKeeper;
class	BMenuBar;


/*
 * ClockworkWaveAppクラスの定義
 */
class ClockworkWaveApp : public BApplication {
// メソッド
public:
    // 初期化と解放
    ClockworkWaveApp(void);
    ~ClockworkWaveApp(void);

private:
    // 起動と終了
    void		ReadyToRun(void);
    void		Quit(void);

    // ビュー部品の生成
    void		MakeClockWin(void);
    void		MakeWaveWin(void);
    BMenuBar*	MakeMenuBar(bool forClock);

    // メニューの応答
    void		MessageReceived(BMessage* message);
    void		AboutRequested(void);
    void		CheckWindow(BMessage* message);
    void		ShowClock(void);
    void		ShowWave(void);
	
    // ウィンドウ操作
    void		ShowWindow(BWindow* inWindow);

// データメンバ
private:
    RegularWindow* fClockWin;   /* 時計表示のウィンドウ */
    RegularWindow* fWaveWin;    /* 水面表示のウィンドウ */
    TimeKeeper*    fTimeKeeper; /* タイミング動作用 */
};


#endif  /* _CLOCKWORK_WAVE_APP_H_ */

#include "ClockworkWaveApp.h"
#include "ClockView.h"
#include "WaveView.h"
#include "TimeKeeper.h"
#include "GUI/RegularWindow.h"
#include "KGUtility/kgDebug.h"

#include <interface/Alert.h>
#include <interface/MenuBar.h>
#include <interface/MenuItem.h>
#include <support/Autolock.h>

/* メッセージのコード */
enum {
    WINDOW_CLOSED = 'wcld',
    SHOW_CLOCK    = 'sclk',
    SHOW_WAVE     = 'swav'
};

/* アバウトダイアログのメッセージ */
const char	kAboutMsg[]	= "ClockworkWave\n\n"
    "Copyright " B_UTF8_COPYRIGHT " 1997-1998 Fort Gunnison, Inc.\n"
    "Author: Shin'ya Koga (koga@ftgun.co.jp)";


/* ClockworkWaveAppクラスの非公開メソッド */
/*
 * 起動と終了; ClockworkWaveApp
 */
void
ClockworkWaveApp::ReadyToRun (void)
{
    /* TimeKeeperオブジェクトを生成して起動 */
    fTimeKeeper = new TimeKeeper();
    fTimeKeeper->Run();
	
    /* 二つのウィンドウを生成して表示 */
    this->MakeClockWin();
    this->MakeWaveWin();
	
    return;
}

void
ClockworkWaveApp::Quit (void)
{
    /* TimeKeeperオブジェクトを停止して解放 */
    (void)fTimeKeeper->Lock();
    fTimeKeeper->Quit();
	
    /* 親クラスのメソッドを実行 */
    BApplication::Quit();
	
    return;
}

/*
 * ビュー部品の生成; ClockworkWaveApp
 */
void
ClockworkWaveApp::MakeClockWin (void)
{
    BMenuBar* aMenuBar;
    BView*    aView;
	
    /* 時計を表示するウィンドウを生成して表示 */
    fClockWin = new RegularWindow(
        BRect(50, 50, 200, 140),
        "Clock Window",
        B_TITLED_WINDOW,
        0,
        WINDOW_CLOSED
    );
    aMenuBar = this->MakeMenuBar(true);
    aView = new ClockView(
        BRect(0, 0, 0, 0), B_FOLLOW_ALL_SIDES, fTimeKeeper
    );
    aView->SetViewColor(0xD0, 0xD0, 0xD0);
    fClockWin->InitContent(aMenuBar, aView);
	
    return;
}

void
ClockworkWaveApp::MakeWaveWin (void)
{
    BMenuBar* aMenuBar;
    BView*    aView;

    /* 水面を表示するウィンドウを生成して表示 */
    fWaveWin  = new RegularWindow(
        BRect(250, 200, 450, 400),
        "Wave Window",
        B_TITLED_WINDOW,
        B_NOT_RESIZABLE|B_NOT_ZOOMABLE,
        WINDOW_CLOSED
    );
    aMenuBar = this->MakeMenuBar(false);
    aView = new WaveView(
        BRect(0, 0, 0, 0), B_FOLLOW_ALL_SIDES, fTimeKeeper
    );
    fWaveWin->InitContent(aMenuBar, aView);

    return;
}

BMenuBar*
ClockworkWaveApp::MakeMenuBar (bool forClock)
{
    BMenuBar* theMenuBar;
    BMenu*    theFileMenu;
	
    /* メニューバーと「File」メニューを生成 */
    theMenuBar = new BMenuBar(BRect(0, 0, 0, 0), B_EMPTY_STRING);
    theFileMenu = new BMenu("File");
    theMenuBar->AddItem(theFileMenu);
	
    /* about項目 */
    (void)theFileMenu->AddItem(
        new BMenuItem(
        "About ClockworkWave" B_UTF8_ELLIPSIS,
        new BMessage(B_ABOUT_REQUESTED)
    )
    );
	
    /* -- */
    (void)theFileMenu->AddSeparatorItem();
	
    /* ウィンドウ表示項目 */
    if (forClock) {
        (void)theFileMenu->AddItem(
            new BMenuItem(
                "Show Wave",
                new BMessage(SHOW_WAVE)
            )
        );
    } else {
        (void)theFileMenu->AddItem(
            new BMenuItem(
                "Show Clock",
                new BMessage(SHOW_CLOCK)
            )
        );
    }
	
    /* -- */
    (void)theFileMenu->AddSeparatorItem();
	
    /* Quit項目 */
    (void)theFileMenu->AddItem(
        new BMenuItem(
            "Quit",
            new BMessage(B_QUIT_REQUESTED),
            'Q'
        )
    );
	
    /* メニューのターゲットを設定 */
    theFileMenu->SetTargetForItems(this);
	
    return theMenuBar;
}

/*
 * メニュー応答; ClockworkWaveApp
 */
void
ClockworkWaveApp::MessageReceived (BMessage* message)
{
    switch (message->what) {
    case WINDOW_CLOSED:
        this->CheckWindow(message); break;
    case SHOW_CLOCK:
        this->ShowClock();          break;
    case SHOW_WAVE:
        this->ShowWave();           break;
    default:
        BApplication::MessageReceived(message);
    }
	
    return;
}

void
ClockworkWaveApp::AboutRequested (void)
{
    BAlert*	alertPanel;
	
    alertPanel = new BAlert("about box", kAboutMsg, "OK");
    (void)alertPanel->Go(NULL);
	
    return;
}

void
ClockworkWaveApp::CheckWindow (BMessage* message)
{
    status_t	sts;
    BWindow*	sender;

    /* 終了したウィンドウを記録 */	
    sts = message->FindPointer(kSender, &sender);
    if (sts != B_OK)
        goto err;
    if (sender == fClockWin)
        fClockWin = NULL;
    else if (sender == fWaveWin)
        fWaveWin = NULL;
    else {
        sts = B_ERROR;
        goto err;
    }
	
    /* 全てのウィンドウが閉じられた場合は終了 */
    if (fClockWin == NULL && fWaveWin == NULL)
        (void)this->PostMessage(B_QUIT_REQUESTED);
	
    return;
err:
    ::Error("ClockworkWaveApp::CheckWindow", sts);
    return;
}

void
ClockworkWaveApp::ShowClock (void)
{
    if (fClockWin == NULL)
        this->MakeClockWin();
    else
        this->ShowWindow(fClockWin);
	
    return;
}

void
ClockworkWaveApp::ShowWave (void)
{
    if (fWaveWin == NULL)
        this->MakeWaveWin();
    else
        this->ShowWindow(fWaveWin);
	
    return;
}

/*
 * ウィンドウ操作; ClockworkWaveApp
 */
void
ClockworkWaveApp::ShowWindow (BWindow* inWindow)
{
    BAutolock	lock(inWindow);
	
    if (inWindow->IsHidden())
        inWindow->Show();
    else if (! inWindow->IsActive())
        inWindow->Activate();
	
    return;
}


/*
 * ClockworkWaveAppクラスの公開メソッド
 */
ClockworkWaveApp::ClockworkWaveApp (void)
    : BApplication("application/x-vnd.FtGUN-ClockworkWave")
{
    fClockWin = fWaveWin = NULL;
    fTimeKeeper = NULL;
}

ClockworkWaveApp::~ClockworkWaveApp (void)
{  /* do nothing */  }

#ifndef _REGULAR_WINDOW_H_
#define _REGULAR_WINDOW_H_

#include <interface/Window.h>

/* 文字列定数 */
extern const char	kSender[];


/*
 * RegularWindowのクラス定義
 */
class RegularWindow : public BWindow {
// メソッド
public:
    // 初期化と解放
    RegularWindow(BRect frame, const char* title,
        window_type type, uint32 flags, uint32 quitMsg);
    virtual ~RegularWindow(void);
    virtual void	InitContent(BView* inContent);
    virtual void	InitContent(BMenuBar* inMenuBar, BView* inContent);
	
    // 終了時処理
    void	Quit(void);

// データメンバ
private:
    uint32	fQuitMsg;	/* 終了通知メッセージのコード */
};


#endif  /* _REGULAR_WINDOW_H_ */

#include "RegularWindow.h"
#include <app/Application.h>
#include <interface/MenuBar.h>
#include <support/Debug.h>

/* 文字列定数 */
const char	kSender[]	= "sender";


/*
 * RegularWindowクラスの公開メソッド
 */
RegularWindow::RegularWindow (BRect frame, const char* title,
        window_type type, uint32 flags, uint32 quitMsg)
    : BWindow(frame, title, type, flags, B_CURRENT_WORKSPACE)
{
    fQuitMsg = quitMsg;
}

RegularWindow::~RegularWindow (void)
{  /* do nothing */  }

void
RegularWindow::InitContent (BView* inContent)
{
#if DEBUG
    this->Lock();
    ASSERT(this->IsHidden());
    ASSERT(this->CountChildren() == 0);
    this->Unlock();
#endif

    BRect	myBounds = this->Bounds();
	
    inContent->ResizeTo(myBounds.Width(), myBounds.Height());
    this->AddChild(inContent);
    this->Show();
	
    return;
}

void
RegularWindow::InitContent (BMenuBar* inMenuBar, BView* inContent)
{
#if DEBUG
    this->Lock();
    ASSERT(this->IsHidden());
    ASSERT(this->CountChildren() == 0);
    this->Unlock();
#endif

    BRect	myBounds = this->Bounds();
    BRect	mbarFrame;
	
    this->AddChild(inMenuBar);
    mbarFrame = inMenuBar->Frame();
    inContent->ResizeTo(
        myBounds.Width(), myBounds.Height() - mbarFrame.Height() - 1);
    inContent->MoveBy(0, mbarFrame.Height() + 1);
    this->AddChild(inContent);	
    this->Show();
	
    return;
}

/*
 * 終了時処理; RegularWindow
 */
void
RegularWindow::Quit (void)
{
    BMessage	quitMessage(fQuitMsg);
	
    /* アプリケーションに終了を通知 */
    quitMessage.AddPointer(kSender, this);
    (void)be_app->PostMessage(&quitMessage);
	
    /* 親クラスのメソッドを実行 */
    BWindow::Quit();
	
    return;
}

#ifndef _CLOCK_VIEW_H_
#define _CLOCK_VIEW_H_

#include <interface/View.h>
#include <time.h>

/* 関連クラス・構造体 */
class	TimeKeeper;


/*
 * ClockViewクラスの定義
 */
class ClockView : public BView {
// メソッド
public:
    // 初期化と解放
    ClockView(BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper);
    ~ClockView(void);
	
private:
    // 描画処理
    void	AttachedToWindow(void);
    void	DetachedFromWindow(void);
    void	Draw(BRect updateRect);
	
    // メッセージ処理
    void	MessageReceived(BMessage* message);
    void	UpdateTime(void);
	
// データメンバ
private:
    TimeKeeper* fTimeKeeper; /* スケジューラ */
    tm          fTime;       /* 現在時刻 */
};


#endif  /* _CLOCK_VIEW_H_ */

#include "ClockView.h"
#include "TimeKeeper.h"
#include "KGUtility/kgDebug.h"

#include <support/Debug.h>
#include <stdio.h>

/* メッセージのコード */
enum {
    UPDATE_TIME	= 'uptm'
};


/* ClockViewクラスの非公開メソッド  */
/*
 * 描画処理; ClockView
 */
void
ClockView::AttachedToWindow (void)
{
    status_t     sts;
    ScheduleInfo theSchedule;

    /* スケジュールを登録 */
    theSchedule.client     = this;
    theSchedule.message    = new BMessage(UPDATE_TIME);
    theSchedule.period     = 1;
    theSchedule.first_time = ::real_time_clock();
    sts = fTimeKeeper->InsertSchedule(theSchedule);
    if (sts != B_OK)
        goto err;
	
    /* 現在の時刻を取得 */
    this->UpdateTime();
	
    return;
err:
    ::Error("ClockView::AttachedToWindow", sts);
    return;
}

void
ClockView::DetachedFromWindow (void)
{
    status_t	sts;
	
    sts = fTimeKeeper->RemoveSchedule(this, UPDATE_TIME);
    if (sts != B_OK)
        goto err;
	
    return;
err:
    ::Error("ClockView::DetachedFromWindow", sts);
    return;
}

void
ClockView::Draw (BRect /* updateRect */)
{
    char       timeStr[64];
    rgb_color  orgColor;

    /* 全体をビューの色で塗りつぶしてクリア */
    orgColor  = this->HighColor();
    this->SetHighColor(this->ViewColor());
    this->FillRect(this->Bounds());
    this->SetHighColor(orgColor());

    /* 時刻表示文字列を描画 */
    this->SetFontSize(30);
    sprintf(timeStr, "%02d:%02d:%02d",
        fTime.tm_hour, fTime.tm_min, fTime.tm_sec);
    this->DrawString(timeStr, BPoint(18, 40));
	
    return;
}

/*
 * メッセージ処理; ClockView
 */
void
ClockView::MessageReceived (BMessage* message)
{
    switch (message->what) {
    case UPDATE_TIME:
        this->UpdateTime();		break;
    default:
        BView::MessageReceived(message);
    }
	
    return;
}

void
ClockView::UpdateTime (void)
{
    time_t	curTime = time(0);

    /* 時刻情報を更新 */
    fTime = *(localtime(&curTime));
	
    /* 新しい時刻を描画 */
    this->Draw(this->Bounds());
	
    return;
}


/*
 * ClockViewクラスの公開メソッド
 */
ClockView::ClockView (
        BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper)
    : BView(frame, "ClockView", resizeMask, B_WILL_DRAW)
{
    ASSERT(inTimeKeeper != NULL);

    fTimeKeeper = inTimeKeeper;
    fTime.tm_hour = fTime.tm_min = fTime.tm_sec = 0;
}

ClockView::~ClockView (void)
{  /* do nothing */  }

#ifndef _WAVE_VIEW_H_
#define _WAVE_VIEW_H_

#include <interface/View.h>

/* 関連クラス・構造体 */
class	TimeKeeper;


/*
 * WaveViewクラスの定義
 */
class WaveView : public BView {
// メソッド
public:
    // 初期化と解放
    WaveView(BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper);
    ~WaveView(void);

private:
    // 描画処理
    void	AttachedToWindow(void);
    void	DetachedFromWindow(void);

    // メッセージ処理
    void	MessageReceived(BMessage* message);
    void	Pulse(void);
    void	UpdateColor(void);
	
// データメンバ
private:
    TimeKeeper* fTimeKeeper;	/* スケジューラ */
    uint8       fCurrColor;		/* 水面の色 */
    float       fWaveRadius;	/* 波紋の半径 */
    BPoint      fWaveOrigin;	/* 波紋の中心 */
};


#endif  /* _WAVE_VIEW_H_ */

#include "WaveView.h"
#include "TimeKeeper.h"
#include "KGUtility/kgDebug.h"

#include <interface/Screen.h>
#include <interface/Window.h>
#include <support/Debug.h>

/* メッセージのコード */
enum {
    UPDATE_COLOR = 'upcl'
};

/* その他の定数 */
const float	kInitialRadius	= 10;	/* 波紋半径の初期値 */


/* WaveViewクラスの非公開メソッド */
/*
 * 描画処理; WaveView
 */
void
WaveView::AttachedToWindow (void)
{
    status_t     sts;
    ScheduleInfo theSchedule;
    BRect        myBounds = this->Bounds();
	
    /* スケジュールを登録 */
    theSchedule.client     = this;
    theSchedule.message    = new BMessage(UPDATE_COLOR);
    theSchedule.period     = 4;
    theSchedule.first_time = ::real_time_clock() + 4;
    sts = fTimeKeeper->InsertSchedule(theSchedule);
    if (sts != B_OK)
        goto err;
	
    /* 水面の色の初期値を設定 */
    this->UpdateColor();
    this->Window()->SetPulseRate(100 * 1000);
	
    /* 波紋の原点座標を決定 */
    fWaveOrigin.x = myBounds.Width() / 2;
    fWaveOrigin.y = myBounds.Height() / 2;
	
    return;
err:
    ::Error("WaveView::AttachedToWindow", sts);
    return;
}

void
WaveView::DetachedFromWindow (void)
{
    status_t	sts;
	
    sts = fTimeKeeper->RemoveSchedule(this, UPDATE_COLOR);
    if (sts != B_OK)
        goto err;
	
    return;
err:
    ::Error("WaveView::DetachedFromWindow", sts);
    return;
}

/*
 * メッセージ処理; WaveView
 */
void
WaveView::MessageReceived (BMessage* message)
{
    switch (message->what) {
    case UPDATE_COLOR:
        this->UpdateColor();	break;
    default:
        BView::MessageReceived(message);
    }
	
    return;
}

void
WaveView::Pulse (void)
{
    BScreen   myScreen(this->Window());
    rgb_color orgRGBColor = this->HighColor();
    uint8     waveColor;

    /* 波紋の色を決定 */	
    waveColor = myScreen.InvertIndex(fCurrColor);
    if (fCurrColor == 247)
        waveColor += 1;
    else if (fCurrColor == 16)
        waveColor -= 2;

    /* 波紋を現在位置に描画 */
    this->SetHighColor(myScreen.ColorForIndex(waveColor));  /* 波紋の色 */
    if (fWaveRadius == kInitialRadius) {  /* 初期状態 */
        this->FillEllipse(fWaveOrigin, fWaveRadius * 2, fWaveRadius * 2);
    } else {  /* 拡がった状態 */
        this->StrokeEllipse(fWaveOrigin,
        kInitialRadius + fWaveRadius, kInitialRadius + fWaveRadius);
        this->SetHighColor(myScreen.ColorForIndex(fCurrColor));
        this->FillEllipse(fWaveOrigin,
        fWaveRadius - kInitialRadius, fWaveRadius - kInitialRadius);
    }
    this->SetHighColor(orgRGBColor);  /* 元のペンカラーを復元 */

    /* 波紋の半径値を更新 */
    if ((fWaveOrigin.x * sqrt(2.0)) <= (fWaveRadius - kInitialRadius))
        fWaveRadius = kInitialRadius;
    else
        fWaveRadius += 1;
	
    return;
}

void
WaveView::UpdateColor (void)
{
    ASSERT(this->Window() != NULL);

    BScreen   myScreen(this->Window());
    rgb_color newColor;

    /* 波紋の色を算出 */
    newColor = myScreen.ColorForIndex(fCurrColor--);
	
    /* 使う色がパレットを一周したら最初に戻す */
    if ((int16)fCurrColor < 0)
        fCurrColor = 255;
	
    return;
}


/*
 * WaveViewクラスの公開メソッド
 */
WaveView::WaveView (
        BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper)
    : BView(frame, "Wave", resizeMask, B_PULSE_NEEDED)
{
    ASSERT(inTimeKeeper != NULL);
	
    fTimeKeeper = inTimeKeeper;
    fCurrColor  = 255;
    fWaveRadius = kInitialRadius;
}

WaveView::~WaveView (void)
{  /* do nothing */  }

#ifndef _CLOCK_VIEW_H_
#define _CLOCK_VIEW_H_

#include "TimedView.h"
#include <time.h>

/*
 * ClockViewクラスの定義
 */
class ClockView : public TimedView {
// メソッド
public:
    // 初期化と解放
    ClockView(BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper);
    ~ClockView(void);

private:
    // 描画処理
    void	AttachedToWindow(void);
    void	DetachedFromWindow(void);
    void	Draw(BRect updateRect);
	
    // メッセージ処理
    void	MessageReceived(BMessage* message);
    void	UpdateTime(void);

// データメンバ
private:
    tm       fTime;       /* 現在時刻 */
    BBitmap* fOffscreen;  /* オフスクリーン描画用 */
};


#endif  /* _CLOCK_VIEW_H_ */

#include "ClockView.h"
#include "TimeKeeper.h"
#include "KGUtility/kgDebug.h"

#include <interface/Bitmap.h>
#include <stdio.h>

/* メッセージのコード */
enum {
    UPDATE_TIME	= 'uptm'
};


/* ClockViewクラスの非公開メソッド */
/*
 * 描画処理; ClockView
 */
void
ClockView::AttachedToWindow (void)
{
    status_t     sts;
    ScheduleInfo theSchedule;
    BView*       theOffView;

    /* 時刻更新スケジュールを登録 */
    theSchedule.client    = this;
    theSchedule.message   = new BMessage(UPDATE_TIME);
    theSchedule.period    = 1;
    theSchedule.first_time = ::real_time_clock();
    sts = this->AddSchedule(theSchedule);
    if (sts != B_OK)
        goto err;

    /* オフスクリーン描画用のBBitmapとBViewを生成 */
    fOffscreen = new BBitmap(this->Bounds(), B_COLOR_8_BIT, true);
    theOffView = new BView(this->Bounds(), "", B_FOLLOW_ALL_SIDES, 0);
    theOffView->SetViewColor(this->ViewColor());
    fOffscreen->AddChild(theOffView);
	
    /* 現在の時刻を取得 */
    this->UpdateTime();
	
    return;
err:
    ::Error("ClockView::AttachedToWindow", sts);
    return;
}

void
ClockView::DetachedFromWindow (void)
{
    status_t	sts;

    /* 時刻更新スケジュールを削除 */
    sts = this->RmvSchedule(UPDATE_TIME);
    if (sts != B_OK)
        goto err;
	
    /* 不要なBBitmapオブジェクトを解放 */
    delete fOffscreen;
    fOffscreen = NULL;

    return;
err:
    ::Error("ClockView::DetachedFromWindow", sts);
    return;
}

void
ClockView::Draw (BRect updateRect)
{
    /* オフスクリーンからVRAMにコピー */
    this->DrawBitmap(fOffscreen, updateRect, updateRect);
	
    return;
}

/*
 * メッセージ処理; ClockView
 */
void
ClockView::MessageReceived (BMessage* message)
{
    switch (message->what) {
    case UPDATE_TIME:
        this->UpdateTime();	break;
    default:
        BView::MessageReceived(message);
    }
	
    return;
}

void
ClockView::UpdateTime (void)
{
    time_t    curTime = time(0);
    char      timeStr[64];
    BView*    offView;
    rgb_color orgColor;
	
    /* 現在時刻情報を更新 */
    fTime = *(localtime(&curTime));
    sprintf(timeStr, "%02d:%02d:%02d",
        fTime.tm_hour, fTime.tm_min, fTime.tm_sec);
	
    /* BBitmapをロック */
    (void)fOffscreen->Lock();

    /* オフスクリーンに時刻を描画 */
    offView  = fOffscreen->ChildAt(0);
    orgColor = offView->HighColor();
    offView->SetHighColor(offView->ViewColor());
    offView->FillRect(offView->Bounds());
    offView->SetHighColor(orgColor);
    offView->SetFontSize(30);
    offView->DrawString(timeStr, BPoint(18, 40));

    /* 更新すべき領域を再描画 */
    this->Draw(offView->Bounds());
	
    /* ロックを解除 */
    fOffscreen->Unlock();
	
    return;
}


/*
 * ClockViewクラスの公開メソッド
 */
ClockView::ClockView (
        BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper)
    : TimedView(frame, "ClockView", resizeMask, B_WILL_DRAW, inTimeKeeper)
{
    fOffscreen = NULL;
}

ClockView::~ClockView (void)
{
    delete fOffscreen;
}

#ifndef _WAVE_VIEW_H_
#define _WAVE_VIEW_H_

#include "TimedView.h"


/*
 * WaveViewクラスの定義
 */
class WaveView : public TimedView {
// メソッド
public:
    // 初期化と解放
    WaveView(BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper);
    ~WaveView(void);

private:
    // 描画処理
    void	AttachedToWindow(void);
    void	DetachedFromWindow(void);
    void	Draw(BRect updateRect);
    void	DrawWave(BView* inTargetView,
        rgb_color waveColor, rgb_color backColor);
	
    // メッセージ処理
    void	MessageReceived(BMessage* message);
    void	Pulse(void);
    void	UpdateColor(void);

// データメンバ
private:
    uint8    fCurrColor;		/* 水面の色 */
    float    fWaveRadius;	/* 波紋の半径 */
    BPoint   fWaveOrigin;	/* 波紋の中心 */
    BBitmap* fOffscreen;		/* オフスクリーン描画用 */
};


#endif  /* _WAVE_VIEW_H_ */

#include "WaveView.h"
#include "TimeKeeper.h"
#include "KGUtility/kgDebug.h"

#include <interface/Bitmap.h>
#include <interface/Screen.h>
#include <support/Debug.h>

/* メッセージのコード */
enum {
    UPDATE_COLOR	= 'upcl'
};

/* その他の定数 */
const float	kInitialRadius	= 10;	/* 波紋半径の初期値 */


/* WaveViewクラスの非公開メソッド */
/*
 * 描画処理; WaveView
 */
void
WaveView::AttachedToWindow (void)
{
    status_t     sts;
    ScheduleInfo theSchedule;
    BRect        myBounds = this->Bounds();
    BView*       theOffView;
	
    /* 表示色更新スケジュールを登録 */
    theSchedule.client     = this;
    theSchedule.message    = new BMessage(UPDATE_COLOR);
    theSchedule.period     = 4;
    theSchedule.first_time = ::real_time_clock() + 4;
    sts = this->AddSchedule(theSchedule);
    if (sts != B_OK)
        goto err;
	
    /* オフスクリーン描画用のBBitmapとBViewを生成 */
    fOffscreen = new BBitmap(myBounds, B_COLOR_8_BIT, true);
    theOffView = new BView(myBounds, "", B_FOLLOW_ALL_SIDES, 0);
    fOffscreen->AddChild(theOffView);
	
    /* 水面の色の初期値を設定 */
    this->UpdateColor();
    this->Window()->SetPulseRate(100 * 1000);
	
    /* 波紋の原点座標を決定 */
    fWaveOrigin.x = myBounds.Width() / 2;
    fWaveOrigin.y = myBounds.Height() / 2;
	
    return;
err:
    ::Error("WaveView::AttachedToWindow", sts);
    return;
}

void
WaveView::DetachedFromWindow (void)
{
    status_t	sts;
	
    /* 表示色更新スケジュールを削除 */
    sts = this->RmvSchedule(UPDATE_COLOR);
    if (sts != B_OK)
        goto err;
	
    /* 不要なBBitmapを解放 */
    delete fOffscreen;
    fOffscreen = NULL;
	
    return;
err:
    ::Error("WaveView::DetachedFromWindow", sts);
    return;
}

void
WaveView::Draw (BRect updateRect)
{
    /* オフスクリーンからVRAMに転送 */
    this->DrawBitmap(fOffscreen, updateRect, updateRect);
	
    return;
}

void
WaveView::DrawWave (
	BView* inTargetView, rgb_color waveColor, rgb_color backColor)
{
    rgb_color	orgRGBColor = inTargetView->HighColor();

    /* 波紋を現在位置に描画 */
    inTargetView->SetHighColor(waveColor);  /* 波紋の色 */
    if (fWaveRadius == kInitialRadius) {  /* 初期状態 */
        inTargetView->FillEllipse(
            fWaveOrigin, fWaveRadius * 2, fWaveRadius * 2);
    } else {  /* 拡がった状態 */
        inTargetView->StrokeEllipse(fWaveOrigin,
            kInitialRadius + fWaveRadius, kInitialRadius + fWaveRadius);
        inTargetView->SetHighColor(backColor);
        inTargetView->FillEllipse(fWaveOrigin,
            fWaveRadius - kInitialRadius, fWaveRadius - kInitialRadius);
    }
    inTargetView->SetHighColor(orgRGBColor);  /* 元のペンカラーを復元 */

    return;
}

/*
 * メッセージ処理; WaveView
 */
void
WaveView::MessageReceived (BMessage* message)
{
    switch (message->what) {
    case UPDATE_COLOR:
        this->UpdateColor();	break;
    default:
        BView::MessageReceived(message);
    }
	
    return;
}

void
WaveView::Pulse (void)
{
    BView*    offView;
    uint8     waveColor;
    BScreen   myScreen(this->Window());
    rgb_color waveRGBColor, backRGBColor;

    /* 波紋の色を決定 */	
    waveColor = myScreen.InvertIndex(fCurrColor);
    if (fCurrColor == 247)
        waveColor += 1;
    else if (fCurrColor == 16)
        waveColor -= 2;
    waveRGBColor = myScreen.ColorForIndex(waveColor);
    backRGBColor = myScreen.ColorForIndex(fCurrColor);
	
    /* 波紋を描画 */
    this->DrawWave(this, waveRGBColor, backRGBColor);

    /* オフスクリーンにも描画 */
    fOffscreen->Lock();
    offView = fOffscreen->ChildAt(0);
    this->DrawWave(offView, waveRGBColor, backRGBColor);
    offView->Window()->Flush();  /* !! */
    fOffscreen->Unlock();

    /* 波紋の半径値を更新 */
    if ((fWaveOrigin.x * sqrt(2.0)) <= (fWaveRadius - kInitialRadius))
        fWaveRadius = kInitialRadius;
    else
        fWaveRadius += 1;
	
    return;
/*
 * 注意:ここでは、オフスクリーン描画を行った後にオフスクリーンウィン
 *  ドウに対してFlush()メソッドを呼び出している。この呼び出しを行わ
 *  ないと、描画内容がオフスクリーンウィンドウへ反映されないうちに
 *  Draw()メソッドによるオンスクリーンへの転送が行われ、正常に描画
 *  されない場合がある。
 */
}

void
WaveView::UpdateColor (void)
{
    ASSERT(this->Window() != NULL);

    BScreen   myScreen(this->Window());
    rgb_color newColor;

    /* 波紋の色を算出 */
    newColor = myScreen.ColorForIndex(fCurrColor--);
	
    /* 使う色がパレットを一周したら最初に戻す */
    if ((int16)fCurrColor < 0)
        fCurrColor = 255;
	
    return;
}


/*
 * WaveViewクラスの公開メソッド
 */
WaveView::WaveView (
        BRect frame, uint32 resizeMask, TimeKeeper* inTimeKeeper)
    : TimedView(frame, "Wave", resizeMask,
        B_PULSE_NEEDED|B_WILL_DRAW, inTimeKeeper)
{
    fCurrColor  = 255;
    fWaveRadius = kInitialRadius;
    fOffscreen  = NULL;
}

WaveView::~WaveView (void)
{
    delete fOffscreen;
}

#ifndef _TIMED_VIEW_H_
#define _TIMED_VIEW_H_

#include <interface/View.h>

/* 関連クラス・構造体 */
class  TimeKeeper;
struct ScheduleInfo;


/*
 * TimedViewクラスの定義
 */
class TimedView : public BView {
// メソッド
public:
    // 初期化と解放
    TimedView(BRect frame, const char* title,
        uint32 resizedMask, uint32 flags, TimeKeeper* inTimeKeeper);
    virtual ~TimedView(void);

protected:
    // スケジュール情報の管理
    status_t	AddSchedule(const ScheduleInfo& inSchedule);
    status_t	RmvSchedule(uint32 theCode);

// データメンバ
private:
    TimeKeeper*	fTimeKeeper;	/* タイミング動作用のスケジューラ */
};


#endif  /* _TIMED_VIEW_H_ */

#include "TimedView.h"
#include "TimeKeeper.h"


/*
 * TimedViewクラスの非公開メソッド
 */
status_t
TimedView::AddSchedule (const ScheduleInfo& inSchedule)
{
    return fTimeKeeper->InsertSchedule(inSchedule);
}

status_t
TimedView::RmvSchedule (uint32 theCode)
{
    return fTimeKeeper->RemoveSchedule(this, theCode);
}


/*
 * TimedViewクラスの公開メソッド
 */
TimedView::TimedView (BRect frame, const char* title,
        uint32 resizeMask, uint32 flags, TimeKeeper* inTimeKeeper)
    : BView(frame, title, resizeMask, flags)
{
    fTimeKeeper = inTimeKeeper;
}

TimedView::~TimedView (void)
{  /* do nothing */  }

#ifndef _TIME_KEEPER_H_
#define _TIME_KEEPER_H_

#include <support/Locker.h>

/* 関連クラス・構造体 */
struct	TaskInfo;


/*
 * メッセージ送付のスケジュール情報(ScheduleInfo)
 */
struct ScheduleInfo {
    BHandler* client;     /* メッセージを送る相手 */
    BMessage* message;    /* 送付するメッセージ */
    int32     period;     /* メッセージを送る間隔(秒単位) */
    uint32    first_time; /* 最初にメッセージを送る時刻(秒単位) */
};

/*
 * TimeKeeperクラスの定義
 */
class TimeKeeper {
// メソッド
public:
    // 初期化と解放
    TimeKeeper(void);
    ~TimeKeeper(void);

    // イベントスケジューリング
    status_t InsertSchedule(const ScheduleInfo& inSchedule);
    status_t RemoveSchedule(const BHandler* inClient, uint32 theCode);
private:
    void     CheckTask(void);

    // クラスメソッド
    static int32 WatchClients(void* data);
    static int   CompareTasks(const void* inTaskA, const void* inTaskB);
	
    // メッセージ送付タスクの操作
    status_t ExecuteHeadTask(void);
    status_t AddTask(TaskInfo* inTask);
    int32    FindTask(const BHandler* inClient, uint32 theCode);

// データメンバ
private:
    thread_id fWatcher;     /* 監視動作用のスレッド */
    bigtime_t fWatchPeriod; /* 監視スレッドのスリープ間隔(u秒単位) */
    BList*    fTaskList;    /* メッセージ送付タスクのリスト */
    BLocker   fLocker;      /* 自身のロック用 */
};


#endif  /* _TIME_KEEPER_H_ */

#include "TimeKeeper.h"
#include "KGUtility/kgDebug.h"

#include <support/Debug.h>


/* メッセージ送付タスク */
struct TaskInfo {
    uint32        exec_time;	/* 遂行時刻 */
    ScheduleInfo  schedule;  /* スケジュール情報 */
};


/* TimeKeeperクラスの非公開メソッド */
/*
 * イベントスケジューリング; TimeKeeper
 */
void
TimeKeeper::CheckTask (void)
{
    BAutolock	lock(fLocker);

    /* 指定時刻に達している全てのタスクを実行 */
    while (! fTaskList->IsEmpty()) {
        TaskInfo*	headTask = (TaskInfo*)fTaskList->FirstItem();
	
        if (headTask->exec_time > ::real_time_clock())
            break;  /* 必要なタスクの実行が終了 */
        (void)this->ExecuteHeadTask();
    }
	
    /* 必要なら監視スレッドを停止 */
    if (fTaskList->IsEmpty())
        (void)::suspend_thread(fWatcher);
	
    return;
}

/*
 * クラスメソッド; TimeKeeper
 */
int32
TimeKeeper::WatchClients (void* data)
{
    TimeKeeper*	theObj = (TimeKeeper*)data;
	
    while (true) {
        /* 必要な時間だけスリープ */
        (void)::snooze(theObj->fWatchPeriod);

        /* タスクをチェック */
        theObj->CheckTask();
    }
	
    return 0;
}

int
TimeKeeper::CompareTasks (const void* inTaskA, const void* inTaskB)
{
    int    retVal = 0;
    uint32 timeA  = (*(TaskInfo**)inTaskA)->exec_time;
    uint32 timeB  = (*(TaskInfo**)inTaskB)->exec_time;
	
    if (timeA < timeB)
        retVal = -1;
    else if (timeA > timeB)
        retVal = 1;
	
    return retVal;
/*
 * 注意:BListの要素間比較手続きには、要素そのもの(ポインタ)ではなく、要
 *		素の配列、すなわちポインタ配列が渡される。このため、渡された引数
 *		に対して参照解除(dereference)する必要があるので注意すること。
 *		('98. 1/7, koga@ftgun.co.jp)
 */
}

/*
 * メッセージ送付タスクの操作; TimeKeeper
 */
status_t
TimeKeeper::ExecuteHeadTask (void)
{
    status_t  sts;
    TaskInfo* theTask;
    BLooper*  target;

    ASSERT(! fTaskList->IsEmpty());

    /* 先頭のタスク情報を取得 */
    theTask = (TaskInfo*)fTaskList->FirstItem();
    target  = theTask->schedule.client->Looper();
    ASSERT(target != NULL);
    ASSERT(theTask->exec_time <= ::real_time_clock());

    /* 送り先にメッセージを送付 */
    sts = target->PostMessage(
        theTask->schedule.message, theTask->schedule.client);
    if (sts != B_OK)
        goto err;
    (void)fTaskList->RemoveItem(theTask);  /* 先頭要素をリストから削除 */

    /* 繰り返し処理なら再度追加 */
    if (theTask->schedule.period > 0) {
        theTask->exec_time += theTask->schedule.period;
        sts = this->AddTask(theTask);
        if (sts != B_OK)
        goto err;
    }

    return B_OK;
err:
    ::Error("TimeKeeper::ExecuteHeadTask", sts);
    return sts;
}

status_t
TimeKeeper::AddTask (TaskInfo* inTask)
{
    /* リストの先頭に要素を追加 */
    (void)fTaskList->AddItem(inTask, 0);

    /* リスト要素を昇順でソート */
    fTaskList->SortItems(CompareTasks);

    return B_OK;
}

int32
TimeKeeper::FindTask (const BHandler* inHandler, uint32 theCode)
{
    int32	theIndex = -1;

    for (int32 i = 0, n = fTaskList->CountItems(); i < n; ++i) {
        TaskInfo*	aTask = (TaskInfo*)fTaskList->ItemAt(i);
		
        if (aTask->schedule.client == inHandler
                && aTask->schedule.message->what == theCode) {
            theIndex = i;
            break;
        }
    }
	
    return theIndex;
}


/* TimeKeeperクラスの公開メソッド */
/*
 * 初期化と解放; TimeKeeper
 */
TimeKeeper::TimeKeeper (void)
{
    fWatcher     = -1;
    fTaskList    = new BList();
    fWatchPeriod = 500 * 1000;  /* 0.5秒 */
}

TimeKeeper::~TimeKeeper (void)
{
    BAutolock	lock(fLocker);

    /* スレッドが生きていたら停止して解放 */
    if (fWatcher >= 0)
        (void)kill_thread(fWatcher);

    /* 不要になったスケジュール情報を解放 */
    while (! fTaskList->IsEmpty()) {
        TaskInfo*	aTask = (TaskInfo*)fTaskList->RemoveItem((int32)0);
		
        delete aTask->schedule.message;
        delete aTask;
    }
    delete fTaskList;
/*
 * 注意:ここでは自身にロックをかけて排他制御を行っているが、これは完全
 *		なものではない。InsertSchedule()やRemoveSchedule()が、デストラ
 *		クタを呼び出したのとは別のスレッドから同時に呼び出された場合、
 *		デストラクタによってfTaskListが解放された後にそれらのメソッドが
 *		実行される可能性があるからである。すなわち、InsertSchedule()や
 *		RemoveSchedule()がfTaskListにアクセスした際に、それが既に解放さ
 *		れて無効な領域になっている可能性のあることを考慮していない。
 *		ここでロックをかけているのは、fWatcherスレッドを kill する際に、
 *		その実行が中途半端な状態で終わらないことを保障するのが目的であ
 *		り、他のメソッドとの間での完全な排他制御を実現するものではない。
 *
 *		 なお、fTaskListを解放したらそれをNULLにセットし、他のメソッド
 *		ではfTaskListがNULLかどうかをチェックするように *改良*したとし
 *		ても、TimeKeeperクラスのインスタンス全体が占める領域はデストラ
 *		クタの解放処理によって無効になるため、問題を解決したことにはな
 *		らない。('98. 3/4, koga@ftgun.co.jp)
 */
}

/*
 * イベントスケジューリング; TimeKeeper
 */
status_t
TimeKeeper::InsertSchedule (const ScheduleInfo& inSchedule)
{
    status_t  sts;
    TaskInfo* newTask = new TaskInfo();
    int32     theIndex;
    BAutolock lock(fLocker);

    /* 既に同じスケジュールがあれば削除 */
    theIndex = this->FindTask(
        inSchedule.client, inSchedule.message->what);
    if (theIndex >= 0)
        (void)fTaskList->RemoveItem(theIndex);
	
    /* タスクリストにエントリを追加 */
    newTask->exec_time = inSchedule.first_time;
    newTask->schedule  = inSchedule;
    sts = this->AddTask(newTask);
    if (sts != B_OK)
        goto err;

    /* 必要なら監視スレッドを生成して起動 */
    if (fWatcher < 0) {
        fWatcher = ::spawn_thread(
            WatchClients, "watcher", B_NORMAL_PRIORITY, this
        );
    }
    sts = ::resume_thread(fWatcher);
    if (sts != B_OK)
        goto err;
	
    return B_OK;
err:
    ::Error("TimeKeeper::InsertSchedule", sts);
    return sts;
/*
 * 注意:上では無条件に resume_thread() を実行しているが、suspend してい
 *		ないスレッドに対しては、この手続きは何もしない。したがって、これ
 *		で問題はない。('97. 12/20, koga@ftgun.co.jp)
 */
}

status_t
TimeKeeper::RemoveSchedule (const BHandler* inClient, uint32 theCode)
{
    status_t  sts;
    TaskInfo* theTask;
    BAutolock lock(fLocker);

    /* タスクリストからエントリを削除 */
    theTask = (TaskInfo*)fTaskList->RemoveItem(
        this->FindTask(inClient, theCode)
    );
    if (! theTask) {
        sts = B_ERROR;
        goto err;  /* 見つからない */
    }
    delete theTask->schedule.message;
    delete theTask;
	
    /* 必要なら監視スレッドを停止 */
    if (fTaskList->IsEmpty())
        (void)::suspend_thread(fWatcher);
	
    return B_OK;
err:
    ::Error("TimeKeeper::RemoveSchedule", sts);
    return sts;
}