SIDPlayer/src/main_beos.cpp

/*
 *  main_beos.cpp - SIDPlayer BeOS main program
 *
 *  SIDPlayer (C) Copyright 1996-2000 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sys.h"

#include <AppKit.h>
#include <InterfaceKit.h>
#include <storage/Path.h>
#include <media/SoundPlayer.h>

#include <stdio.h>

#include "main.h"
#include "prefs_window.h"


// Message codes
const uint32 MSG_NEW_MODULE = 'load';
const uint32 MSG_NEW_SONG = 'song';
const uint32 MSG_SHOW_PREFS = 'pref';
const uint32 MSG_PLAY_PAUSE = 'plpa';
const uint32 MSG_STOP = 'stop';
const uint32 MSG_NEXT = 'next';
const uint32 MSG_PREV = 'prev';


class MainWindow;
class SpeedSlider;

// Application object
class SIDPlayer : public BApplication {
public:
        SIDPlayer();
        virtual ~SIDPlayer();
        virtual void ArgvReceived(int32 argc, char **argv);
        virtual void RefsReceived(BMessage *msg);
        virtual void MessageReceived(BMessage *msg);
        virtual void ReadyToRun(void);
        virtual void AboutRequested(void);

private:
        static void buffer_proc(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format);

        MainWindow *main_window;
        PrefsWindow *prefs_window;
        BSoundPlayer player;
        bool player_stopped;
};


// Main window object
class MainWindow : public BWindow {
public:
        MainWindow();
        virtual bool QuitRequested(void);
        virtual void MessageReceived(BMessage *msg);

private:
        BStringView *make_name_display(BRect frame, char *label_text, BView *parent);

        rgb_color fill_color;

        BStringView *name_view;
        BStringView *author_view;
        BStringView *copyright_view;
        BStringView *position_view;
        SpeedSlider *speed_slider;
};


// Top view object (handles drag&drop)
class TopView : public BView {
public:
        TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags);
        virtual void MessageReceived(BMessage *msg);
        virtual void KeyDown(const char *bytes, int32 numBytes);
};


// Buttons
class PlayPauseButton : public BButton {
public:
        PlayPauseButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};

class StopButton : public BButton {
public:
        StopButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};

class NextButton : public BButton {
public:
        NextButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};

class PrevButton : public BButton {
public:
        PrevButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};


// Speed slider
class SpeedSlider : public BSlider {
public:
        SpeedSlider(BRect frame, const char *name) : BSlider(frame, name, "Speed", NULL, -100, 100, B_TRIANGLE_THUMB)
        {
                SetHashMarks(B_HASH_MARKS_TOP);
                SetHashMarkCount(3);
                const rgb_color bar_color = {128, 128, 216, 0};
                SetBarColor(bar_color);
                SetValue(0);
        }
        virtual ~SpeedSlider() {}
        virtual void SetValue(int32 value)
        {
                int percent = value < 0 ? 100 + value / 2 : 100 + value;
                sprintf(status, "%d%%", percent);
                SIDAdjustSpeed(percent);
                BSlider::SetValue(value);
        }
        virtual char *UpdateText(void) const
        {
                return status;
        }

private:
        mutable char status[32];
};


/*
 *  Application constructor
 */

#if B_HOST_IS_LENDIAN
const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_LITTLE_ENDIAN, 4096};
#else
const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_BIG_ENDIAN, 4096};
#endif

SIDPlayer::SIDPlayer() : BApplication("application/x-vnd.cebix-SIDPlayer"), player(&audio_format, "SIDPlayer", buffer_proc)
{
        main_window = NULL;
        player.SetHasData(true);
        player_stopped = true;
}


/*
 *  Application destructor
 */

SIDPlayer::~SIDPlayer()
{
        main_window = NULL;
        prefs_window = NULL;
        player.Stop();
        player_stopped = true;
}


/*
 *  Shell arguments received
 */

void SIDPlayer::ArgvReceived(int32 argc, char **argv)
{
        if (argc >= 2) {
                player.Stop();
                LoadPSIDFile(argv[1]);
                player.Start();
                player_stopped = false;
                if (main_window)
                        main_window->PostMessage(MSG_NEW_MODULE);
        }
}


/*
 *  Tracker arguments received
 */

void SIDPlayer::RefsReceived(BMessage *msg)
{
        entry_ref the_ref;
        if (msg->FindRef("refs", &the_ref) == B_NO_ERROR) {
                BEntry the_entry;
                if (the_entry.SetTo(&the_ref) == B_NO_ERROR) {
                        if (the_entry.IsFile()) {
                                BPath the_path;
                                the_entry.GetPath(&the_path);
                                player.Stop();
                                LoadPSIDFile(the_path.Path());
                                player.Start();
                                player_stopped = false;
                                if (main_window)
                                        main_window->PostMessage(MSG_NEW_MODULE);
                        }
                }
        }
}


/*
 *  Message received
 */

void SIDPlayer::MessageReceived(BMessage *msg)
{
        switch (msg->what) {

                case B_SIMPLE_DATA:     // Dropped message
                        RefsReceived(msg);
                        break;

                case MSG_SHOW_PREFS:
                        if (!prefs_window_open)
                                prefs_window = new PrefsWindow();
                        else if (prefs_window)
                                prefs_window->Activate(true);
                        break;

                case MSG_PLAY_PAUSE:
                        if (player_stopped) {
                                player.Start();
                                player_stopped = false;
                        } else {
                                player.Stop();
                                player_stopped = true;
                        }
                        break;

                case MSG_STOP:
                        player.Stop();
                        player_stopped = true;
                        SelectSong(current_song);
                        main_window->PostMessage(MSG_NEW_SONG);
                        break;

                case MSG_NEXT:
                        if (current_song < number_of_songs-1) {
                                player.Stop();
                                SelectSong(current_song + 1);
                                main_window->PostMessage(MSG_NEW_SONG);
                                if (!player_stopped)
                                        player.Start();
                        }
                        break;

                case MSG_PREV:
                        if (current_song > 0) {
                                player.Stop();
                                SelectSong(current_song - 1);
                                main_window->PostMessage(MSG_NEW_SONG);
                                if (!player_stopped)
                                        player.Start();
                        }
                        break;

                default:
                        BApplication::MessageReceived(msg);
                        break;
        }
}


/*
 *  Arguments processed, open player window
 */

void SIDPlayer::ReadyToRun(void)
{
        main_window = new MainWindow();
        if (psid_loaded)
                main_window->PostMessage(MSG_NEW_MODULE);
}


/*
 *  Show About window
 */

void AboutWindow(void)
{
        BAlert *theAlert = new BAlert("",
                        "SIDPlayer\nVersion " VERSION "\n\n"
                        "Copyright " B_UTF8_COPYRIGHT " 1996-2000 Christian Bauer\n"
                        "E-mail: Christian.Bauer@uni-mainz.de\n"
                        "http://www.uni-mainz.de/~bauec002/\n\n"
                        "SIDPlayer comes with ABSOLUTELY NO\n"
                        "WARRANTY. This is free software, and\n"
                        "you are welcome to redistribute it\n"
                        "under the terms of the GNU General\n"
                        "Public License.\n",
                        "OK", NULL, NULL, B_WIDTH_FROM_LABEL);

        BTextView *theText = theAlert->TextView();
        if (theText) {
                theText->SetStylable(true);
                theText->Select(0, 9);
                BFont ourFont;
                theText->SetFontAndColor(be_bold_font);
                theText->GetFontAndColor(2, &ourFont, NULL);
                ourFont.SetSize(24);
                theText->SetFontAndColor(&ourFont);
        }
        theAlert->Go();
}

void SIDPlayer::AboutRequested(void)
{
        AboutWindow();
}


/*
 *  SoundPlayer buffer procedure
 */

void SIDPlayer::buffer_proc(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format)
{
        SIDCalcBuffer((uint8 *)buffer, size);
}


/*
 *  Main window constructor
 */

MainWindow::MainWindow() : BWindow(BRect(0, 0, 284, 96), "SIDPlayer", B_TITLED_WINDOW, B_NOT_ZOOMABLE | B_NOT_RESIZABLE | B_ASYNCHRONOUS_CONTROLS)
{
        fill_color = ui_color(B_PANEL_BACKGROUND_COLOR);
        BRect b = Bounds();

        // Move window to right position
        Lock();
        MoveTo(80, 80);

        // Create menu bar
        BMenuBar *bar = new BMenuBar(BRect(0, 0, b.right, b.bottom), "menubar");
        BMenu *menu = new BMenu("File");
        menu->AddItem(new BMenuItem("About SIDPlayer" B_UTF8_ELLIPSIS, new BMessage(B_ABOUT_REQUESTED)));
        menu->AddItem(new BSeparatorItem());
        menu->AddItem(new BMenuItem("Sound Control" B_UTF8_ELLIPSIS, new BMessage(MSG_SHOW_PREFS), 'P'));
        menu->AddItem(new BSeparatorItem());
        menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
        menu->SetTargetForItems(be_app);
        bar->AddItem(menu);
        AddChild(bar);
        SetKeyMenuBar(bar);
        float menu_height = bar->Bounds().Height();

        // Resize window to fit menu bar
        ResizeBy(0, menu_height);

        // Light gray background
        TopView *top = new TopView(BRect(0, menu_height, b.right, b.bottom + menu_height), "main", B_FOLLOW_NONE, B_WILL_DRAW);
        AddChild(top);
        top->SetViewColor(fill_color);

        // Name/author/copyright display
        name_view = make_name_display(BRect(0, 5, 279, 21), "Name", top);
        author_view = make_name_display(BRect(0, 25, 279, 41), "Author", top);
        copyright_view = make_name_display(BRect(0, 45, 279, 61), "Copyright", top);

        // Buttons
        top->AddChild(new PlayPauseButton(BRect(6, 67, 36, 91), new BMessage(MSG_PLAY_PAUSE)));
        top->AddChild(new StopButton(BRect(37, 67, 67, 91), new BMessage(MSG_STOP)));
        top->AddChild(new PrevButton(BRect(68, 67, 98, 91), new BMessage(MSG_PREV)));
        top->AddChild(new NextButton(BRect(99, 67, 129, 91), new BMessage(MSG_NEXT)));

        // Position indicator
        top->AddChild(position_view = new BStringView(BRect(134, 72, 193, 85), "position", ""));
        position_view->SetViewColor(fill_color);

        // Speed slider
        top->AddChild(speed_slider = new SpeedSlider(BRect(194, 62, 279, 63), "speed"));

        // Show window
        top->MakeFocus();
        Unlock();
        Show();
}


/*
 *  Create name display field
 */

BStringView *MainWindow::make_name_display(BRect frame, char *label_text, BView *parent)
{
        // Label to the left of the display field
        BRect label_rect = frame;
        label_rect.right = label_rect.left + 65;

        BStringView *label = new BStringView(label_rect, "", label_text);
        parent->AddChild(label);
        label->SetViewColor(fill_color);
        label->SetLowColor(fill_color);
        label->SetAlignment(B_ALIGN_RIGHT);
        label->SetFont(be_bold_font);

        // Box around display field
        BRect frame_rect = frame;
        frame_rect.left += 70;

        BBox *box = new BBox(frame_rect);
        parent->AddChild(box);
        box->SetViewColor(fill_color);
        box->SetLowColor(fill_color);

        // The display field
        BRect textview_rect = frame_rect;
        textview_rect.OffsetTo(0, 0);
        textview_rect.InsetBy(4, 2);

        BStringView *text = new BStringView(textview_rect, "", "");
        box->AddChild(text);
        text->SetViewColor(fill_color);
        text->SetLowColor(fill_color);
        text->SetFont(be_plain_font);
        return text;
}


/*
 *  Main window closed, quit program
 */

bool MainWindow::QuitRequested(void)
{
        be_app->PostMessage(B_QUIT_REQUESTED);
        return true;
}


/*
 *  Message received
 */

void MainWindow::MessageReceived(BMessage *msg)
{
        switch (msg->what) {
                case MSG_NEW_MODULE:
                        // Update text views
                        Lock();
                        name_view->SetText(module_name);
                        author_view->SetText(author_name);
                        copyright_view->SetText(copyright_info);
                        Unlock();
                        // falls through

                case MSG_NEW_SONG:
                        // Update position indicator and speed slider
                        if (number_of_songs > 0) {
                                char str[16];
                                sprintf(str, "Song %d/%d", current_song + 1, number_of_songs);
                                position_view->SetText(str);
                        }
                        speed_slider->SetValue(0);
                        break;

                case MSG_SHOW_PREFS:
                case MSG_PLAY_PAUSE:
                case MSG_STOP:
                case MSG_NEXT:
                case MSG_PREV:
                        be_app->PostMessage(msg);
                        break;

                default:
                        BWindow::MessageReceived(msg);
                        break;
        }
}


/*
 *  TopView handles dropped messages (load new PSID module) and keypresses
 */

TopView::TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags)
 : BView(frame, name, resizingMode, flags) {}

void TopView::MessageReceived(BMessage *msg)
{
        if (msg->what == B_SIMPLE_DATA)
                be_app->PostMessage(msg);
        else
                BView::MessageReceived(msg);
}

void TopView::KeyDown(const char *bytes, int32 numBytes)
{
        BMessage *msg = Window()->CurrentMessage();
        uint32 modifiers = 0;
        msg->FindInt32("modifiers", (int32 *)&modifiers);

        switch (bytes[0]) {
                case 'p':
                case 'P':
                        Window()->PostMessage(MSG_PLAY_PAUSE);
                        break;

                case B_ESCAPE:
                case B_SPACE:
                case 's':
                case 'S':
                        Window()->PostMessage(MSG_STOP);
                        break;

                case B_LEFT_ARROW:
                        Window()->PostMessage(MSG_PREV);
                        break;

                case B_RIGHT_ARROW:
                case 'n':
                case 'N':
                        Window()->PostMessage(MSG_NEXT);
                        break;

                case 'q':
                case 'Q':
                        be_app->PostMessage(B_QUIT_REQUESTED);
                        break;
        }
}


/*
 *  Play/Pause button
 */

PlayPauseButton::PlayPauseButton(BRect frame, BMessage *msg) : BButton(frame, "play", "", msg) {};

void PlayPauseButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw play/pause image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillRect(BRect(11, 8, 13, 16));
        FillTriangle(BPoint(16, 8), BPoint(16, 16), BPoint(20, 12));
}


/*
 *  Stop button
 */

StopButton::StopButton(BRect frame, BMessage *msg) : BButton(frame, "stop", "", msg) {};

void StopButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw stop image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillRect(BRect(11, 8, 20, 16));
}


/*
 *  "Next" button
 */

NextButton::NextButton(BRect frame, BMessage *msg) : BButton(frame, "next", "", msg) {};

void NextButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw "next" image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillTriangle(BPoint(12, 8), BPoint(12, 16), BPoint(16, 12));
        FillRect(BRect(17, 8, 19, 16));
}


/*
 *  "Prev" button
 */

PrevButton::PrevButton(BRect frame, BMessage *msg) : BButton(frame, "prev", "", msg) {};

void PrevButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw "prev" image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillRect(BRect(12, 8, 14, 16));
        FillTriangle(BPoint(19, 8), BPoint(19, 16), BPoint(15, 12));
}


/*
 *  Main program
 */

int main(int argc, char **argv)
{
        InitAll();
        SIDPlayer *the_app = new SIDPlayer();
        the_app->Run();
        delete the_app;
        ExitAll();
        return 0;
}
Revision:	1.2
Committed:	2000-10-10T21:57:21Z (23 years, 6 months ago) by cebix
Branch:	MAIN
Changes since 1.1:	+1 -1 lines
Log Message:	bumped version number to 4.1
#	User	Rev	Content
1	cebix	1.1	/*
2			* main_beos.cpp - SIDPlayer BeOS main program
3			*
4			* SIDPlayer (C) Copyright 1996-2000 Christian Bauer
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sys.h"
22
23			#include <AppKit.h>
24			#include <InterfaceKit.h>
25			#include <storage/Path.h>
26			#include <media/SoundPlayer.h>
27
28			#include <stdio.h>
29
30			#include "main.h"
31			#include "prefs_window.h"
32
33
34			// Message codes
35			const uint32 MSG_NEW_MODULE = 'load';
36			const uint32 MSG_NEW_SONG = 'song';
37			const uint32 MSG_SHOW_PREFS = 'pref';
38			const uint32 MSG_PLAY_PAUSE = 'plpa';
39			const uint32 MSG_STOP = 'stop';
40			const uint32 MSG_NEXT = 'next';
41			const uint32 MSG_PREV = 'prev';
42
43
44			class MainWindow;
45			class SpeedSlider;
46
47			// Application object
48			class SIDPlayer : public BApplication {
49			public:
50			SIDPlayer();
51			virtual ~SIDPlayer();
52			virtual void ArgvReceived(int32 argc, char **argv);
53			virtual void RefsReceived(BMessage *msg);
54			virtual void MessageReceived(BMessage *msg);
55			virtual void ReadyToRun(void);
56			virtual void AboutRequested(void);
57
58			private:
59			static void buffer_proc(void cookie, void buffer, size_t size, const media_raw_audio_format &format);
60
61			MainWindow *main_window;
62			PrefsWindow *prefs_window;
63			BSoundPlayer player;
64			bool player_stopped;
65			};
66
67
68			// Main window object
69			class MainWindow : public BWindow {
70			public:
71			MainWindow();
72			virtual bool QuitRequested(void);
73			virtual void MessageReceived(BMessage *msg);
74
75			private:
76			BStringView make_name_display(BRect frame, char label_text, BView *parent);
77
78			rgb_color fill_color;
79
80			BStringView *name_view;
81			BStringView *author_view;
82			BStringView *copyright_view;
83			BStringView *position_view;
84			SpeedSlider *speed_slider;
85			};
86
87
88			// Top view object (handles drag&drop)
89			class TopView : public BView {
90			public:
91			TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags);
92			virtual void MessageReceived(BMessage *msg);
93			virtual void KeyDown(const char *bytes, int32 numBytes);
94			};
95
96
97			// Buttons
98			class PlayPauseButton : public BButton {
99			public:
100			PlayPauseButton(BRect frame, BMessage *msg);
101			virtual void Draw(BRect update);
102			};
103
104			class StopButton : public BButton {
105			public:
106			StopButton(BRect frame, BMessage *msg);
107			virtual void Draw(BRect update);
108			};
109
110			class NextButton : public BButton {
111			public:
112			NextButton(BRect frame, BMessage *msg);
113			virtual void Draw(BRect update);
114			};
115
116			class PrevButton : public BButton {
117			public:
118			PrevButton(BRect frame, BMessage *msg);
119			virtual void Draw(BRect update);
120			};
121
122
123			// Speed slider
124			class SpeedSlider : public BSlider {
125			public:
126			SpeedSlider(BRect frame, const char *name) : BSlider(frame, name, "Speed", NULL, -100, 100, B_TRIANGLE_THUMB)
127			{
128			SetHashMarks(B_HASH_MARKS_TOP);
129			SetHashMarkCount(3);
130			const rgb_color bar_color = {128, 128, 216, 0};
131			SetBarColor(bar_color);
132			SetValue(0);
133			}
134			virtual ~SpeedSlider() {}
135			virtual void SetValue(int32 value)
136			{
137			int percent = value < 0 ? 100 + value / 2 : 100 + value;
138			sprintf(status, "%d%%", percent);
139			SIDAdjustSpeed(percent);
140			BSlider::SetValue(value);
141			}
142			virtual char *UpdateText(void) const
143			{
144			return status;
145			}
146
147			private:
148			mutable char status[32];
149			};
150
151
152			/*
153			* Application constructor
154			*/
155
156			#if B_HOST_IS_LENDIAN
157			const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_LITTLE_ENDIAN, 4096};
158			#else
159			const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_BIG_ENDIAN, 4096};
160			#endif
161
162			SIDPlayer::SIDPlayer() : BApplication("application/x-vnd.cebix-SIDPlayer"), player(&audio_format, "SIDPlayer", buffer_proc)
163			{
164			main_window = NULL;
165			player.SetHasData(true);
166			player_stopped = true;
167			}
168
169
170			/*
171			* Application destructor
172			*/
173
174			SIDPlayer::~SIDPlayer()
175			{
176			main_window = NULL;
177			prefs_window = NULL;
178			player.Stop();
179			player_stopped = true;
180			}
181
182
183			/*
184			* Shell arguments received
185			*/
186
187			void SIDPlayer::ArgvReceived(int32 argc, char **argv)
188			{
189			if (argc >= 2) {
190			player.Stop();
191			LoadPSIDFile(argv[1]);
192			player.Start();
193			player_stopped = false;
194			if (main_window)
195			main_window->PostMessage(MSG_NEW_MODULE);
196			}
197			}
198
199
200			/*
201			* Tracker arguments received
202			*/
203
204			void SIDPlayer::RefsReceived(BMessage *msg)
205			{
206			entry_ref the_ref;
207			if (msg->FindRef("refs", &the_ref) == B_NO_ERROR) {
208			BEntry the_entry;
209			if (the_entry.SetTo(&the_ref) == B_NO_ERROR) {
210			if (the_entry.IsFile()) {
211			BPath the_path;
212			the_entry.GetPath(&the_path);
213			player.Stop();
214			LoadPSIDFile(the_path.Path());
215			player.Start();
216			player_stopped = false;
217			if (main_window)
218			main_window->PostMessage(MSG_NEW_MODULE);
219			}
220			}
221			}
222			}
223
224
225			/*
226			* Message received
227			*/
228
229			void SIDPlayer::MessageReceived(BMessage *msg)
230			{
231			switch (msg->what) {
232
233			case B_SIMPLE_DATA: // Dropped message
234			RefsReceived(msg);
235			break;
236
237			case MSG_SHOW_PREFS:
238			if (!prefs_window_open)
239			prefs_window = new PrefsWindow();
240			else if (prefs_window)
241			prefs_window->Activate(true);
242			break;
243
244			case MSG_PLAY_PAUSE:
245			if (player_stopped) {
246			player.Start();
247			player_stopped = false;
248			} else {
249			player.Stop();
250			player_stopped = true;
251			}
252			break;
253
254			case MSG_STOP:
255			player.Stop();
256			player_stopped = true;
257			SelectSong(current_song);
258			main_window->PostMessage(MSG_NEW_SONG);
259			break;
260
261			case MSG_NEXT:
262			if (current_song < number_of_songs-1) {
263			player.Stop();
264			SelectSong(current_song + 1);
265			main_window->PostMessage(MSG_NEW_SONG);
266			if (!player_stopped)
267			player.Start();
268			}
269			break;
270
271			case MSG_PREV:
272			if (current_song > 0) {
273			player.Stop();
274			SelectSong(current_song - 1);
275			main_window->PostMessage(MSG_NEW_SONG);
276			if (!player_stopped)
277			player.Start();
278			}
279			break;
280
281			default:
282			BApplication::MessageReceived(msg);
283			break;
284			}
285			}
286
287
288			/*
289			* Arguments processed, open player window
290			*/
291
292			void SIDPlayer::ReadyToRun(void)
293			{
294			main_window = new MainWindow();
295			if (psid_loaded)
296			main_window->PostMessage(MSG_NEW_MODULE);
297			}
298
299
300			/*
301			* Show About window
302			*/
303
304			void AboutWindow(void)
305			{
306			BAlert *theAlert = new BAlert("",
307	cebix	1.2	"SIDPlayer\nVersion " VERSION "\n\n"
308	cebix	1.1	"Copyright " B_UTF8_COPYRIGHT " 1996-2000 Christian Bauer\n"
309			"E-mail: Christian.Bauer@uni-mainz.de\n"
310			"http://www.uni-mainz.de/~bauec002/\n\n"
311			"SIDPlayer comes with ABSOLUTELY NO\n"
312			"WARRANTY. This is free software, and\n"
313			"you are welcome to redistribute it\n"
314			"under the terms of the GNU General\n"
315			"Public License.\n",
316			"OK", NULL, NULL, B_WIDTH_FROM_LABEL);
317
318			BTextView *theText = theAlert->TextView();
319			if (theText) {
320			theText->SetStylable(true);
321			theText->Select(0, 9);
322			BFont ourFont;
323			theText->SetFontAndColor(be_bold_font);
324			theText->GetFontAndColor(2, &ourFont, NULL);
325			ourFont.SetSize(24);
326			theText->SetFontAndColor(&ourFont);
327			}
328			theAlert->Go();
329			}
330
331			void SIDPlayer::AboutRequested(void)
332			{
333			AboutWindow();
334			}
335
336
337			/*
338			* SoundPlayer buffer procedure
339			*/
340
341			void SIDPlayer::buffer_proc(void cookie, void buffer, size_t size, const media_raw_audio_format &format)
342			{
343			SIDCalcBuffer((uint8 *)buffer, size);
344			}
345
346
347			/*
348			* Main window constructor
349			*/
350
351			MainWindow::MainWindow() : BWindow(BRect(0, 0, 284, 96), "SIDPlayer", B_TITLED_WINDOW, B_NOT_ZOOMABLE \| B_NOT_RESIZABLE \| B_ASYNCHRONOUS_CONTROLS)
352			{
353			fill_color = ui_color(B_PANEL_BACKGROUND_COLOR);
354			BRect b = Bounds();
355
356			// Move window to right position
357			Lock();
358			MoveTo(80, 80);
359
360			// Create menu bar
361			BMenuBar *bar = new BMenuBar(BRect(0, 0, b.right, b.bottom), "menubar");
362			BMenu *menu = new BMenu("File");
363			menu->AddItem(new BMenuItem("About SIDPlayer" B_UTF8_ELLIPSIS, new BMessage(B_ABOUT_REQUESTED)));
364			menu->AddItem(new BSeparatorItem());
365			menu->AddItem(new BMenuItem("Sound Control" B_UTF8_ELLIPSIS, new BMessage(MSG_SHOW_PREFS), 'P'));
366			menu->AddItem(new BSeparatorItem());
367			menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
368			menu->SetTargetForItems(be_app);
369			bar->AddItem(menu);
370			AddChild(bar);
371			SetKeyMenuBar(bar);
372			float menu_height = bar->Bounds().Height();
373
374			// Resize window to fit menu bar
375			ResizeBy(0, menu_height);
376
377			// Light gray background
378			TopView *top = new TopView(BRect(0, menu_height, b.right, b.bottom + menu_height), "main", B_FOLLOW_NONE, B_WILL_DRAW);
379			AddChild(top);
380			top->SetViewColor(fill_color);
381
382			// Name/author/copyright display
383			name_view = make_name_display(BRect(0, 5, 279, 21), "Name", top);
384			author_view = make_name_display(BRect(0, 25, 279, 41), "Author", top);
385			copyright_view = make_name_display(BRect(0, 45, 279, 61), "Copyright", top);
386
387			// Buttons
388			top->AddChild(new PlayPauseButton(BRect(6, 67, 36, 91), new BMessage(MSG_PLAY_PAUSE)));
389			top->AddChild(new StopButton(BRect(37, 67, 67, 91), new BMessage(MSG_STOP)));
390			top->AddChild(new PrevButton(BRect(68, 67, 98, 91), new BMessage(MSG_PREV)));
391			top->AddChild(new NextButton(BRect(99, 67, 129, 91), new BMessage(MSG_NEXT)));
392
393			// Position indicator
394			top->AddChild(position_view = new BStringView(BRect(134, 72, 193, 85), "position", ""));
395			position_view->SetViewColor(fill_color);
396
397			// Speed slider
398			top->AddChild(speed_slider = new SpeedSlider(BRect(194, 62, 279, 63), "speed"));
399
400			// Show window
401			top->MakeFocus();
402			Unlock();
403			Show();
404			}
405
406
407			/*
408			* Create name display field
409			*/
410
411			BStringView MainWindow::make_name_display(BRect frame, char label_text, BView *parent)
412			{
413			// Label to the left of the display field
414			BRect label_rect = frame;
415			label_rect.right = label_rect.left + 65;
416
417			BStringView *label = new BStringView(label_rect, "", label_text);
418			parent->AddChild(label);
419			label->SetViewColor(fill_color);
420			label->SetLowColor(fill_color);
421			label->SetAlignment(B_ALIGN_RIGHT);
422			label->SetFont(be_bold_font);
423
424			// Box around display field
425			BRect frame_rect = frame;
426			frame_rect.left += 70;
427
428			BBox *box = new BBox(frame_rect);
429			parent->AddChild(box);
430			box->SetViewColor(fill_color);
431			box->SetLowColor(fill_color);
432
433			// The display field
434			BRect textview_rect = frame_rect;
435			textview_rect.OffsetTo(0, 0);
436			textview_rect.InsetBy(4, 2);
437
438			BStringView *text = new BStringView(textview_rect, "", "");
439			box->AddChild(text);
440			text->SetViewColor(fill_color);
441			text->SetLowColor(fill_color);
442			text->SetFont(be_plain_font);
443			return text;
444			}
445
446
447			/*
448			* Main window closed, quit program
449			*/
450
451			bool MainWindow::QuitRequested(void)
452			{
453			be_app->PostMessage(B_QUIT_REQUESTED);
454			return true;
455			}
456
457
458			/*
459			* Message received
460			*/
461
462			void MainWindow::MessageReceived(BMessage *msg)
463			{
464			switch (msg->what) {
465			case MSG_NEW_MODULE:
466			// Update text views
467			Lock();
468			name_view->SetText(module_name);
469			author_view->SetText(author_name);
470			copyright_view->SetText(copyright_info);
471			Unlock();
472			// falls through
473
474			case MSG_NEW_SONG:
475			// Update position indicator and speed slider
476			if (number_of_songs > 0) {
477			char str[16];
478			sprintf(str, "Song %d/%d", current_song + 1, number_of_songs);
479			position_view->SetText(str);
480			}
481			speed_slider->SetValue(0);
482			break;
483
484			case MSG_SHOW_PREFS:
485			case MSG_PLAY_PAUSE:
486			case MSG_STOP:
487			case MSG_NEXT:
488			case MSG_PREV:
489			be_app->PostMessage(msg);
490			break;
491
492			default:
493			BWindow::MessageReceived(msg);
494			break;
495			}
496			}
497
498
499			/*
500			* TopView handles dropped messages (load new PSID module) and keypresses
501			*/
502
503			TopView::TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags)
504			: BView(frame, name, resizingMode, flags) {}
505
506			void TopView::MessageReceived(BMessage *msg)
507			{
508			if (msg->what == B_SIMPLE_DATA)
509			be_app->PostMessage(msg);
510			else
511			BView::MessageReceived(msg);
512			}
513
514			void TopView::KeyDown(const char *bytes, int32 numBytes)
515			{
516			BMessage *msg = Window()->CurrentMessage();
517			uint32 modifiers = 0;
518			msg->FindInt32("modifiers", (int32 *)&modifiers);
519
520			switch (bytes[0]) {
521			case 'p':
522			case 'P':
523			Window()->PostMessage(MSG_PLAY_PAUSE);
524			break;
525
526			case B_ESCAPE:
527			case B_SPACE:
528			case 's':
529			case 'S':
530			Window()->PostMessage(MSG_STOP);
531			break;
532
533			case B_LEFT_ARROW:
534			Window()->PostMessage(MSG_PREV);
535			break;
536
537			case B_RIGHT_ARROW:
538			case 'n':
539			case 'N':
540			Window()->PostMessage(MSG_NEXT);
541			break;
542
543			case 'q':
544			case 'Q':
545			be_app->PostMessage(B_QUIT_REQUESTED);
546			break;
547			}
548			}
549
550
551			/*
552			* Play/Pause button
553			*/
554
555			PlayPauseButton::PlayPauseButton(BRect frame, BMessage *msg) : BButton(frame, "play", "", msg) {};
556
557			void PlayPauseButton::Draw(BRect update)
558			{
559			// First draw normal button
560			BButton::Draw(update);
561
562			// Then draw play/pause image on top of it
563			if (Value())
564			SetHighColor(255, 255, 255);
565			else
566			SetHighColor(0, 0, 0);
567
568			FillRect(BRect(11, 8, 13, 16));
569			FillTriangle(BPoint(16, 8), BPoint(16, 16), BPoint(20, 12));
570			}
571
572
573			/*
574			* Stop button
575			*/
576
577			StopButton::StopButton(BRect frame, BMessage *msg) : BButton(frame, "stop", "", msg) {};
578
579			void StopButton::Draw(BRect update)
580			{
581			// First draw normal button
582			BButton::Draw(update);
583
584			// Then draw stop image on top of it
585			if (Value())
586			SetHighColor(255, 255, 255);
587			else
588			SetHighColor(0, 0, 0);
589
590			FillRect(BRect(11, 8, 20, 16));
591			}
592
593
594			/*
595			* "Next" button
596			*/
597
598			NextButton::NextButton(BRect frame, BMessage *msg) : BButton(frame, "next", "", msg) {};
599
600			void NextButton::Draw(BRect update)
601			{
602			// First draw normal button
603			BButton::Draw(update);
604
605			// Then draw "next" image on top of it
606			if (Value())
607			SetHighColor(255, 255, 255);
608			else
609			SetHighColor(0, 0, 0);
610
611			FillTriangle(BPoint(12, 8), BPoint(12, 16), BPoint(16, 12));
612			FillRect(BRect(17, 8, 19, 16));
613			}
614
615
616			/*
617			* "Prev" button
618			*/
619
620			PrevButton::PrevButton(BRect frame, BMessage *msg) : BButton(frame, "prev", "", msg) {};
621
622			void PrevButton::Draw(BRect update)
623			{
624			// First draw normal button
625			BButton::Draw(update);
626
627			// Then draw "prev" image on top of it
628			if (Value())
629			SetHighColor(255, 255, 255);
630			else
631			SetHighColor(0, 0, 0);
632
633			FillRect(BRect(12, 8, 14, 16));
634			FillTriangle(BPoint(19, 8), BPoint(19, 16), BPoint(15, 12));
635			}
636
637
638			/*
639			* Main program
640			*/
641
642			int main(int argc, char **argv)
643			{
644			InitAll();
645			SIDPlayer *the_app = new SIDPlayer();
646			the_app->Run();
647			delete the_app;
648			ExitAll();
649			return 0;
650			}