/*[

* Copyright 1986 - 1993, 1998, 2004 Thomas Williams, Colin Kelley

*

* Permission to use, copy, and distribute this software and its

* documentation for any purpose with or without fee is hereby granted,

* provided that the above copyright notice appear in all copies and

* that both that copyright notice and this permission notice appear

* in supporting documentation.

*

* Permission to modify the software is granted, but not the right to

* distribute the complete modified source code. Modifications are to

* be distributed as patches to the released version. Permission to

* distribute binaries produced by compiling modified sources is granted,

* provided you

* 1. distribute the corresponding source modifications from the

* released version in the form of a patch file along with the binaries,

* 2. add special version identification to distinguish your version

* in addition to the base release version number,

* 3. provide your name and address as the primary contact for the

* support of your modified version, and

* 4. retain our contact information in regard to use of the base

* software.

* Permission to distribute the released version of the source code along

* with corresponding source modifications in the form of a patch file is

* granted with same provisions 2 through 4 for binary distributions.

*

* This software is provided "as is" without express or implied warranty

* to the extent permitted by applicable law.

]*/

#include <Application.h>

#include <Messenger.h>

#include <Message.h>

#include <Roster.h>

#include <Window.h>

#include <View.h>

#include <MenuBar.h>

#include <Menu.h>

#include <MenuItem.h>

#include <FilePanel.h>

#include <Path.h>

#include <Entry.h>

#include <TextView.h>

#include <ScrollView.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include "constants.h"

#include "GPBitmap.h"

#include "GPView.h"

#include "GPApp.h"

#include "GPWindow.h"

// Application's signature

const char *APP_SIGNATURE = "application/x-vnd.Xingo-gnuplotViewer";

BRect windowRect(50,50,600,400);

//

// main

//

// The main() function's only real job in a basic BeOS

// application is to create the BApplication object

// and run it.

//

int main(void) {

GPApp theApp; // The application object

theApp.Run();

return 0;

}

//

// GPApp::GPApp

//

// The constructor for the WEApp class. This

// will create our window.

//

GPApp::GPApp()

: BApplication(APP_SIGNATURE) {

window_count = 0; // No windows yet

next_untitled_number = 1; // Next window is "Untitled 1"

// Create the Open file panel

// openPanel = new BFilePanel;

}

//

// GPApp::MessageReceived

//

// Handle incoming messages. In particular, handle the

// WINDOW_REGISTRY_ADD and WINDOW_REGISTRY_SUB messages.

//

void GPApp::MessageReceived(BMessage *message) {

switch(message->what) {

case WINDOW_REGISTRY_ADD:

{

bool need_id = false;

BMessage reply(WINDOW_REGISTRY_ADDED);

if (message->FindBool("need_id", &need_id) == B_OK) {

if (need_id) {

reply.AddInt32("new_window_number", next_untitled_number);

next_untitled_number++;

}

window_count++;

}

reply.AddRect("rect", windowRect);

windowRect.OffsetBy(20,20);

message->SendReply(&reply);

break;

}

case WINDOW_REGISTRY_SUB:

window_count--;

if (!window_count) {

Quit();

}

break;

case MENU_FILE_OPEN:

// openPanel->Show(); // Show the file panel

break;

default:

BApplication::MessageReceived(message);

break;

}

}

//

// GPApp::RefsReceived

//

// Handle a refs received message.

//

void GPApp::RefsReceived(BMessage *message) {

entry_ref ref; // The entry_ref to open

status_t err; // The error code

int32 ref_num; // The index into the ref list

// Loop through the ref list and open each one

#if 0

ref_num = 0;

do {

if ((err = message->FindRef("refs", ref_num, &ref)) != B_OK) {

return;

}

new GPWindow(windowRect, &ref);

ref_num++;

} while (1);

#endif

}

void GPApp::ReadyToRun(void)

{

io_thread = spawn_thread(&io_loop, "gnuplot io_loop", B_LOW_PRIORITY, NULL);

resume_thread(io_thread);

}

int32 GPApp::io_loop(void* data)

{

static plot_struct plot_array[MAX_WINDOWS];

int32 res = 1;

while(res)

res = io_task(plot_array);

return res;

}

int32 GPApp::io_task(plot_struct *plot_array)

{

char buf[256];

struct plot_struct *plot = plot_array;

FILE *fp = stdin;

BMessage msg(bmsgNewCmd);

int cnt = 0;

while (fgets(buf, 256, fp)) {

// printf("Got : %s", buf);

switch (*buf) {

case 'G': /* enter graphics mode */

{

//printf("entering gfx mode\n");

int plot_number = atoi(buf + 1); /* 0 if none specified */

if (plot_number < 0 || plot_number >= MAX_WINDOWS)

plot_number = 0;

//printf("plot for window number %d\n", plot_number);

plot = plot_array + plot_number;

prepare_plot(plot, plot_number);

continue;

}

case 'E': /* leave graphics mode / suspend */

{

// BMessage msg(bmsgBitmapDirty);

msg.AddInt32("numcmds",cnt);

msg.AddPointer("cmds", plot->commands);

if(plot->window)

plot->window->PostMessage(&msg);

// printf("displaying %d cmds, %X at %X\n",cnt,plot->commands[0],&plot->commands[0]);

// display(plot);

cnt = 0;

return 1;

}

case 'R': /* leave x11 mode */

{

//printf("leaving gfx mode\n");

return 0;

}

default:

{

// msg.AddString("cmd",buf);

// plot->window->PostMessage(&msg);

store_command(buf, plot);

cnt++;

continue;

}

}

}

/* get here if fgets fails */

return (feof(fp) || ferror(fp)) ? 0 : 1;

}

void GPApp::prepare_plot(plot_struct *plot, int term_number)

{

int i;

for (i = 0; i < plot->ncommands; ++i)

free(plot->commands[i]);

plot->ncommands = 0;

if (!plot->posn_flags) {

/* first time this window has been used - use default or -geometry

* settings

*/

plot->posn_flags = 1;

plot->x = 50;

plot->y = 20;

plot->width = 400;

plot->height = 400;

}

if (!plot->window) {

windowRect.Set(plot->x,plot->y,plot->width,plot->height);

plot->window = new GPWindow(windowRect);

} else {

BMessage msg(bmsgClrCmd);

plot->window->PostMessage(&msg);

}

}

void GPApp::display(plot_struct *plot)

{

BMessage msg(bmsgBitmapDirty);

if(plot->window)

plot->window->PostMessage(&msg);

}

/* store a command in a plot structure */

void GPApp::store_command(char *buffer, plot_struct *plot)

{

char *p;

// BMessage msg(bmsgNewCmd);

// FPRINTF((stderr, "Store in %d : %s", plot - plot_array, buffer));

if (plot->ncommands >= plot->max_commands) {

plot->max_commands = plot->max_commands * 2 + 1;

plot->commands = (plot->commands)

? (char **) realloc(plot->commands, plot->max_commands * sizeof(char *))

: (char **) malloc(sizeof(char *));

}

p = (char *) malloc((unsigned) strlen(buffer) + 1);

if (!plot->commands || !p) {

fputs("gnuplot: can't get memory. aborted.\n", stderr);

exit(1);

}

plot->commands[plot->ncommands++] = strcpy(p, buffer);

// msg.AddString("cmd",buffer);

// plot->window->PostMessage(&msg);

}