mirror/tesseract
1
0
Fork 0
mirror of https://github.com/tesseract-ocr/tesseract.git synced 2025-06-20 19:40:40 +08:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

Updated graphics output for new java-based display

Browse Source 
git-svn-id: https://tesseract-ocr.googlecode.com/svn/trunk@149 d0cd1f9f-072b-0410-8dd7-cf729c803f20
This commit is contained in:
theraysmith 2008-02-01 00:50:56 +00:00
parent 89a5284c69
commit 1a23b25eeb
22 changed files with 2055 additions and 3561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
viewer/Makefile.am
View File

@ -1,10 +1,9 @@
SUBDIRS = SUBDIRS =
AM_CPPFLAGS = -I$(top_srcdir)/image -I$(top_srcdir)/ccutil AM_CPPFLAGS =
include_HEADERS = \ include_HEADERS = \
evntlst.h evnts.h grphics.h grphshm.h sbgconst.h sbgdefs.h \ scrollview.h svmnode.h svutil.h svpaint.cpp
sbgtypes.h showim.h
lib_LIBRARIES = libtesseract_viewer.a lib_LIBRARIES = libtesseract_viewer.a
libtesseract_viewer_a_SOURCES = \ libtesseract_viewer_a_SOURCES = \
evntlst.cpp grphics.cpp evnts.cpp showim.cpp grphshm.cpp scrollview.cpp svmnode.cpp svutil.cpp

12
viewer/Makefile.in
View File

@ -75,13 +75,13 @@ RANLIB = @RANLIB@
VERSION = @VERSION@ VERSION = @VERSION@
SUBDIRS = SUBDIRS =
AM_CPPFLAGS = -I$(top_srcdir)/image -I$(top_srcdir)/ccutil AM_CPPFLAGS =
include_HEADERS = evntlst.h evnts.h grphics.h grphshm.h sbgconst.h sbgdefs.h sbgtypes.h showim.h include_HEADERS = scrollview.h svmnode.h svutil.h svpaint.cpp
lib_LIBRARIES = libtesseract_viewer.a lib_LIBRARIES = libtesseract_viewer.a
libtesseract_viewer_a_SOURCES = evntlst.cpp grphics.cpp evnts.cpp showim.cpp grphshm.cpp libtesseract_viewer_a_SOURCES = scrollview.cpp svmnode.cpp svutil.cpp
mkinstalldirs = $(SHELL) $(top_srcdir)/config/mkinstalldirs mkinstalldirs = $(SHELL) $(top_srcdir)/config/mkinstalldirs
CONFIG_HEADER = ../config_auto.h CONFIG_HEADER = ../config_auto.h
@ -94,8 +94,7 @@ CPPFLAGS = @CPPFLAGS@
LDFLAGS = @LDFLAGS@ LDFLAGS = @LDFLAGS@
LIBS = @LIBS@ LIBS = @LIBS@
libtesseract_viewer_a_LIBADD = libtesseract_viewer_a_LIBADD =
libtesseract_viewer_a_OBJECTS = evntlst.o grphics.o evnts.o showim.o \ libtesseract_viewer_a_OBJECTS = scrollview.o svmnode.o svutil.o
grphshm.o
AR = ar AR = ar
CXXFLAGS = @CXXFLAGS@ CXXFLAGS = @CXXFLAGS@
CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
@ -110,8 +109,7 @@ DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = tar TAR = tar
GZIP_ENV = --best GZIP_ENV = --best
DEP_FILES = .deps/evntlst.P .deps/evnts.P .deps/grphics.P \ DEP_FILES = .deps/scrollview.P .deps/svmnode.P .deps/svutil.P
.deps/grphshm.P .deps/showim.P
SOURCES = $(libtesseract_viewer_a_SOURCES) SOURCES = $(libtesseract_viewer_a_SOURCES)
OBJECTS = $(libtesseract_viewer_a_OBJECTS) OBJECTS = $(libtesseract_viewer_a_OBJECTS)

344
viewer/evntlst.cpp
View File

@ -1,344 +0,0 @@
/**********************************************************************
* File: evntlst.c (Formerly eventlst.c)
* Description: Code to manipulate lists of events.
* Author: Ray Smith
* Created: Fri Nov 01 11:02:52 GMT 1991
*
* (C) Copyright 1991, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "mfcpch.h"
#include "grphshm.h"
#include "grphics.h"
#ifdef __UNIX__
#include <unistd.h>
#include <signal.h>
//#include "pipes.h"
#include "fileerr.h"
//#include "sbderrs.h"
//#include "grpherr.h"
#elif defined (__MSW32__)
#include <io.h>
#include <process.h>
#else
#include <unistd.h>
#endif
#include "evntlst.h"
#define EXTERN
//anything new in queue
EXTERN BOOL8 event_waiting = FALSE;
#ifdef __UNIX__
//semaphore count
static INT32 event_critical_section = 0;
//true if pending
static BOOL8 event_pending = FALSE;
EXTERN BOOL8 handler_set; //true if signal handler on
EXTERN STRING_VAR (events_logfile, "", "File to log events to");
EXTERN STRING_VAR (events_playback, "", "File to read events from");
/**********************************************************************
* event_handler
*
* Handler for signal.
* If not critical, read events now, otherwise, set pending flag.
**********************************************************************/
void event_handler( //signal handler
int, //signal
int, //code
struct sigcontext *scp //info for sigvector
) {
// scp->sc_syscall_action=SIG_RESTART; //restart sys calls
event_pending = TRUE;
if (!event_critical_section) {
lock_events();
unlock_events();
}
}
/**********************************************************************
* check_event
*
* See if any events are available, and if there are, return 1, else 0.
**********************************************************************/
BOOL8 check_event( /*test for event */
INT16 fd, /*window to wait on */
BOOL8 wait /*set if waiting */
) {
GRAPHICS_EVENT event; /*event from daemon */
SBD_GRAPHICS_EVENT sbd_event; //event from pipe
BOOL8 gotone; /*repeat while do */
INT32 time; /*time to select */
INT32 typein; //input type
INT32 keyin; //input key
INT32 fdin; //input fd
int scanresult; //of fscanf
static FILE *eventsin = NULL; //input file
// && sbfds[fd].used!=1)
if (fd < 0 || fd > maxsbfd || fd > 0) {
// BADSBFD.error("check_event",TESSLOG,NULL); /*report error*/
return FALSE;
}
time = wait ? AWAIT_TIME : CHECK_TIME;
gotone = FALSE;
while (!gotone
&& (events_playback.string ()[0] != '\0' || eventsin != NULL)) {
if (eventsin == NULL && events_playback.string ()[0] != '\0') {
if ((eventsin = fopen (events_playback.string (), "r")) == NULL)
CANTOPENFILE.error ("check_event", TESSLOG,
events_playback.string ());
//remove name
events_playback.set_value (NULL);
}
if (eventsin != NULL) {
scanresult =
fscanf (eventsin,
INT32FORMAT " " INT32FORMAT "(%f,%f) on " INT32FORMAT,
&typein, &keyin, &event.x, &event.y, &fdin);
if (scanresult != 5) {
if (scanresult == EOF)
fprintf (stderr, "Closing input event file\n");
else
fprintf (stderr, "Error on event input: copied %d values\n",
scanresult);
fclose(eventsin);
eventsin = NULL;
}
else {
// fprintf(stderr,"Read input on %d\n", fdin );
event.type = (INT8) typein;
event.key = (char) keyin;
event.fildes = fdin;
add_event(&event); //got one
gotone = gotone || fd == 0 || fd == event.fildes;
/*know if we got one */
}
}
}
while (!gotone) { // && select_read(shminfo.fds[INFD],time)!=0) /*event available*/
if (read (shminfo.fds[INFD], &sbd_event, sizeof (SBD_GRAPHICS_EVENT))
!= sizeof (SBD_GRAPHICS_EVENT))
READFAILED.error ("check_event", EXIT, "sbdaemon pipe");
if (sbd_event.type != QUEUE_CLEAR) {
event.fildes = sbd_event.fd;
event.type = sbd_event.type;
event.key = sbd_event.key;
event.x = sbd_event.x;
event.y = sbd_event.y;
event.next = NULL;
add_event(&event); /*add event to queue */
/*know if we got one */
gotone = gotone || fd == 0 || fd == event.fildes;
}
else
kick_daemon(COUNT_READS); /*keep count accurate */
time = CHECK_TIME;
}
return gotone;
}
#else
EXTERN HANDLE event_sem = NULL; //event lock
/**********************************************************************
* event_reader
*
* A separate thread that reads the input from the pipe and places
* events in the appropriate queue. This thread also calls any appropriate
* event handler on receiving an event.
**********************************************************************/
void event_reader( /*read events */
void *param /*file descriptor */
) {
#ifndef __MAC__
//real file descriptor
HANDLE *fdptr = (HANDLE *) param;
HANDLE fd = *fdptr; //real file descriptor
unsigned long nread; //bytes read
SBD_GRAPHICS_EVENT event; /*event from daemon */
GRAPHICS_EVENT real_event; //converted format
char pipe_char[2]; //from pipe
INT32 pipe_index; //index to event queue
event_id = GetCurrentThreadId ();
while (ReadFile (fd, pipe_char, 2, &nread, NULL) != 0 && nread == 2) {
pipe_index = EVENT_HEAD;
event = EVENT_INDEX (pipe_index);
pipe_index++;
if (pipe_index >= EVENTSIZE)
pipe_index = 0;
EVENT_HEAD = pipe_index;
if (event.type != QUEUE_CLEAR) {
real_event.fildes = event.fd;
real_event.type = event.type;
real_event.key = event.key;
real_event.x = event.x;
real_event.y = event.y;
real_event.next = NULL;
add_event(&real_event); /*add event to queue */
}
else
kick_daemon(COUNT_READS); /*got acknowledge */
}
CloseHandle(fd);
*fdptr = NULL;
_endthread();
#endif
}
#endif
/**********************************************************************
* add_event
*
* Adds an event from the sbdaemon to the correct event queue.
**********************************************************************/
void add_event( /*add an event */
GRAPHICS_EVENT *event /*event to add */
) {
GRAPHICS_EVENT *newevent; /*new event */
EVENT_HANDLER handler; //avoid race hazards
GRAPHICS_EVENT sel_event; //selection
//last button down
static GRAPHICS_EVENT last_down;
#ifdef __UNIX__
static FILE *eventsout = NULL; //output file
static STRING outname; //output name
//doing anything
if (events_logfile.string ()[0] != '\0' || eventsout != NULL) {
if (eventsout != NULL //already open
&& outname != (STRING &) events_logfile) {
fclose(eventsout); //finished that one
eventsout = NULL;
}
//needs opening
if (eventsout == NULL && events_logfile.string ()[0] != '\0') {
//save name
outname = events_logfile.string ();
if ((eventsout = fopen (outname.string (), "w")) == NULL)
CANTOPENFILE.error ("add_event", TESSLOG, outname.string ());
}
if (eventsout != NULL)
fprintf (eventsout, "%d %d(%f,%f) on %d\n",
event->type, event->key, event->x, event->y, event->fildes);
}
#endif
// fprintf(stderr,"Received event of type %d at (%f,%f) on %d\n",
// event->type,event->x,event->y,event->fildes);
event->fd = &sbfds[event->fildes];
switch (event->type) {
case DOWN_EVENT:
last_down = *event; //save it
handler = sbfds[event->fildes].click_handler;
if (handler != NULL) {
(*handler) (event);
return; //done it
}
break;
case UP_EVENT:
sel_event = *event;
if (last_down.x > event->x)
sel_event.xmax = last_down.x;
else {
sel_event.xmax = event->x;
sel_event.x = last_down.x;
}
if (last_down.y > event->y)
sel_event.ymax = last_down.y;
else {
sel_event.ymax = event->y;
sel_event.y = last_down.y;
}
handler = sbfds[event->fildes].selection_handler;
if (handler != NULL) {
(*handler) (&sel_event);
return; //done it
}
break;
case KEYPRESS_EVENT:
handler = sbfds[event->fildes].key_handler;
if (handler != NULL) {
(*handler) (event);
return; //done it
}
break;
case DESTROY_EVENT:
handler = sbfds[event->fildes].destroy_handler;
if (handler != NULL) {
(*handler) (event);
// return; //done it
}
break;
}
lock_events();
newevent = new GRAPHICS_EVENT;
if (newevent != NULL) {
*newevent = *event; /*copy event */
/*first event */
if (sbfds[event->fildes].events == NULL)
sbfds[event->fildes].events = newevent;
else
/*add to end */
sbfds[event->fildes].lastevent->next = newevent;
/*is new end */
sbfds[event->fildes].lastevent = newevent;
newevent->next = NULL;
}
event_waiting = TRUE; //added to queue
unlock_events();
}
/**********************************************************************
* lock_events
*
* Lock out event handler to protect data structures.
**********************************************************************/
void lock_events() { //lock
#ifdef __UNIX__
event_critical_section++;
#elif defined (__MSW32__)
WaitForSingleObject (event_sem, (unsigned long) -1);
#endif
}
/**********************************************************************
* unlock_events
*
* Unlock. If event pending deal with it.
**********************************************************************/
void unlock_events() { //lock
#ifdef __UNIX__
if (event_pending && event_critical_section == 1) {
//get all events
while (check_event (0, FALSE));
event_pending = FALSE;
}
event_critical_section--;
#elif defined (__MSW32__)
//release it
ReleaseSemaphore (event_sem, 1, NULL);
#endif
}

51
viewer/evntlst.h
View File

@ -1,51 +0,0 @@
/**********************************************************************
* File: evntlst.h (Formerly eventlst.h)
* Description: Code to manipulate lists of events.
* Author: Ray Smith
* Created: Fri Nov 01 11:02:52 GMT 1991
*
* (C) Copyright 1991, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef EVNTLST_H
#define EVNTLST_H
#include "sbgtypes.h"
extern BOOL8 event_waiting; //anything new in queue
#ifdef __UNIX__
#include "varable.h"
extern BOOL8 handler_set; //true if signal handler on
extern STRING_VAR_H (events_logfile, "", "File to log events to");
extern STRING_VAR_H (events_playback, "", "File to read events from");
void event_handler( //signal handler
int, //signal
int, //code
struct sigcontext *scp //info for sigvector
);
BOOL8 check_event( /*test for event */
INT16 fd, /*window to wait on */
BOOL8 wait /*set if waiting */
);
#else /* */
extern HANDLE event_sem; //event lock
void event_reader( /*read events */
void *param /*file descriptor */
);
#endif
void add_event( /*add an event */
GRAPHICS_EVENT *event /*event to add */
);
void lock_events(); //lock
void unlock_events(); //lock
#endif

349
viewer/evnts.cpp
View File

@ -1,349 +0,0 @@
/**********************************************************************
* File: evnts.c (Formerly events.c)
* Description: Additional functions needed to receive graphics events.
* Author: Ray Smith
* Created: Thu May 24 14:13:00 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "mfcpch.h"
#ifdef __UNIX__
#include "sbderrs.h"
#include "fileerr.h"
#include "grpherr.h"
#endif
#include "grphshm.h"
#include "evntlst.h"
#include "evnts.h"
#define EXTERN
DLLSYM EVENT_HANDLER win_selection_handler;
WINDOW (*await_event_func) (WINDOW, BOOL8, INT8, GRAPHICS_EVENT *) =
def_await_event;
//local non-public functions
GRAPHICS_EVENT *find_event( /*wait for event */
INT16 &fd, /*window to wait on */
BOOL8 wait, /*waiting flag */
INT8 event_type /*type to look for */
);
/*search for event */
GRAPHICS_EVENT *search_event_queue(INT16 &fd, /*queue to search */
INT8 event_type /*type to search for */
);
/*search for event */
GRAPHICS_EVENT *search_single_queue(INT16 fd, /*queue to search */
INT8 event_type /*type to search for */
);
/**********************************************************************
* await_selection
*
* Wait (or check) for a selection on the given (or all) fd and return it.
**********************************************************************/
DLLSYM WINDOW await_selection( /*wait for selection */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
float &xmin, /*coords of selection */
float &ymin, /*coords of selection */
float &xmax, /*coords of selection */
float &ymax /*coords of selection */
) {
GRAPHICS_EVENT event; /*return event */
win = await_event (win, wait, SELECT_EVENT, &event);
if (event.type == DESTROY_EVENT)
return NULL; //was destroyed
if (win != NULL) {
xmin = event.x; /*get coords */
ymin = event.y;
xmax = event.xmax; /*get coords */
ymax = event.ymax;
}
return win;
}
/**********************************************************************
* await_click
*
* Wait (or check) for a click on the given (or all) fd and return it.
**********************************************************************/
DLLSYM WINDOW await_click( /*wait for click */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
float &x, /*coords of click */
float &y /*coords of click */
) {
GRAPHICS_EVENT event; /*return event */
win = await_event (win, wait, DOWN_EVENT, &event);
if (event.type == DESTROY_EVENT)
return NULL; //was destroyed
if (win != NULL) {
x = event.x; /*get coords */
y = event.y;
}
return win;
}
/**********************************************************************
* await_key
*
* Wait (or check) for a key on the given (or all) fd and return it.
**********************************************************************/
DLLSYM WINDOW await_key( /*wait for key */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
char &c /*return character */
) {
GRAPHICS_EVENT event; /*return event */
win = await_event (win, wait, KEYPRESS_EVENT, &event);
if (event.type == DESTROY_EVENT)
return NULL; //was destroyed
if (win != NULL)
c = event.key; /*get keypress */
return win;
}
/**********************************************************************
* await_event
*
* Wait (or check) for a event on the given (or all) fd and return it.
**********************************************************************/
DLLSYM WINDOW def_await_event( /*wait for event */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
INT8 event_type, /*type to wait for */
GRAPHICS_EVENT *out_event /*output event */
) {
GRAPHICS_EVENT *event; /*return event */
INT16 fd; //file descriptor
if (win == NULL)
fd = 0;
else
fd = win->get_fd ();
/*look for one */
event = find_event (fd, wait, event_type);
if (event == NULL)
return NULL; /*not found */
else {
*out_event = *event; /*copy event */
if (event->type != DESTROY_EVENT)
delete event; //free the element
return out_event->fd;
}
}
/**********************************************************************
* find_event
*
* Search the queue for an event of a given type, and return it.
* Read or wait until one turns up if there is not one already.
**********************************************************************/
GRAPHICS_EVENT *find_event( /*wait for event */
INT16 &fd, /*window to wait on */
BOOL8 wait, /*waiting flag */
INT8 event_type /*type to look for */
) {
GRAPHICS_EVENT *event; /*return event */
/*look for one */
event = search_event_queue (fd, event_type);
if (event == NULL) {
do {
#ifdef __UNIX__
if (check_event (fd, wait))
#elif defined (__MSW32__)
if (wait)
Sleep (50);
if (event_waiting)
#endif
{
// fprintf(stderr,"Got an event:searching queue %d\n",fd);
/*try after reading */
event = search_event_queue (fd, event_type);
}
}
while (wait && event == NULL);
}
// if (event!=NULL)
// event->fd=&sbfds[fd];
return event; /*event located */
}
/**********************************************************************
* search_event_queue
*
* Search the event queue(s) for events of a particular type.
* If found, it is removed from the queue and returned.
**********************************************************************/
GRAPHICS_EVENT *search_event_queue( /*search for event */
INT16 &fd, /*queue to search */
INT8 event_type /*type to search for */
) {
GRAPHICS_EVENT *event; /*event from daemon */
INT16 testfd; /*test window */
if (fd < 0 || fd > maxsbfd || fd > 0 && sbfds[fd].used != 1) {
return NULL;
}
if (fd > 0)
/*just one to search */
return search_single_queue (fd, event_type);
else {
for (testfd = 1; testfd < maxsbfd; testfd++) {
if (sbfds[testfd].used) {
event = search_single_queue (testfd, event_type);
if (event != NULL) {
fd = testfd; /*successful window */
return event; /*got one */
}
}
}
}
return NULL; /*found nothing */
}
/**********************************************************************
* search_single_queue
*
* Search the event queue for events of a particular type.
* If found, it is removed from the queue and returned.
**********************************************************************/
GRAPHICS_EVENT *search_single_queue( /*search for event */
INT16 fd, /*queue to search */
INT8 event_type /*type to search for */
) {
GRAPHICS_EVENT *event; /*event from daemon */
GRAPHICS_EVENT *prev; /*previous event */
GRAPHICS_EVENT *event2; /*2nd event */
GRAPHICS_EVENT *prev2; /*2nd previous */
GRAPHICS_EVENT *nextevent; /*next event in list */
BOOL8 any_destroy = FALSE;
lock_events();
event_waiting = FALSE; //done a scan
prev = NULL; /*previous event */
event2 = NULL; /*2nd event */
if (event_type == ANY_EVENT) {
event = sbfds[fd].events; /*start of queue */
}
else if (event_type == SELECT_EVENT) {
for (prev = NULL, event = sbfds[fd].events; event != NULL
&& event->type != DOWN_EVENT; event = nextevent) {
//Delete up events that are in the list prior to a down event
nextevent = event->next; /*next in list */
if (event->type == UP_EVENT) {
if (prev == NULL)
/*new head */
sbfds[fd].events = nextevent;
else
prev->next = nextevent;/*delete event */
if (nextevent == NULL)
/*new last element */
sbfds[fd].lastevent = prev;
delete event;
}
else
prev = event;
if (event->type == DESTROY_EVENT)
any_destroy = TRUE;
}
if (event == NULL) {
unlock_events();
if (any_destroy)
return search_single_queue (fd, DESTROY_EVENT);
return NULL; /*no good */
}
for (prev2 = event, event2 = event->next; event2 != NULL
&& event2->type != UP_EVENT;
prev2 = event2, event2 = event2->next);
if (event2 == NULL) {
unlock_events();
return NULL; /*no good */
}
if (prev2 != event) { /*got some intervening */
for (prev2 = event->next; prev2 != event2; prev2 = nextevent) {
nextevent = prev2->next;
delete prev2;
}
}
event->next = event2->next; /*cut out event2 */
event2->next = NULL; /*event is new end */
event->xmax = event2->x; /*get coords */
event->ymax = event2->y;
if (event->x > event->xmax) {
event->xmax = event->x;
event->x = event2->x; /*get coords */
}
if (event->y > event->ymax) {
event->ymax = event->y;
event->y = event2->y;
}
delete event2; //free the element
}
else {
for (prev = NULL, event = sbfds[fd].events; event != NULL
&& event->type != DESTROY_EVENT
&& event->type != event_type; event = nextevent) {
nextevent = event->next; /*next in list */
/*delete up in front of down */
if (event->type == UP_EVENT && event_type == DOWN_EVENT) {
if (prev == NULL)
/*new head */
sbfds[fd].events = nextevent;
else
prev->next = nextevent;/*delete event */
if (nextevent == NULL)
/*new last element */
sbfds[fd].lastevent = prev;
delete event;
}
else
prev = event; /*trailing ptr */
}
}
if (event == NULL) {
unlock_events();
return NULL; /*no good */
}
if (event->type != DESTROY_EVENT) {
if (prev == NULL)
/*new head */
sbfds[fd].events = event->next;
else
prev->next = event->next; /*delete event */
if (event->next == NULL)
sbfds[fd].lastevent = prev;/*new last event */
event->next = NULL; /*possible 2nd event */
}
unlock_events();
return event; /*got one!! */
}

52
viewer/evnts.h
View File

@ -1,52 +0,0 @@
/**********************************************************************
* File: evnts.h (Formerly events.h)
* Description: Header of functions and types needed for using events.
* Author: Ray Smith
* Created: Thu May 24 15:14:45 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef EVNTS_H
#define EVNTS_H
#include "grphics.h"
extern DLLSYM EVENT_HANDLER win_selection_handler;
DLLSYM WINDOW await_selection( /*wait for selection */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
float &xmin, /*coords of selection */
float &ymin, /*coords of selection */
float &xmax, /*coords of selection */
float &ymax /*coords of selection */
);
DLLSYM WINDOW await_click( /*wait for click */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
float &x, /*coords of click */
float &y /*coords of click */
);
DLLSYM WINDOW await_key( /*wait for key */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
char &c /*return character */
);
DLLSYM WINDOW def_await_event( /*wait for event */
WINDOW win, /*window to wait on */
BOOL8 wait, /*waiting flag */
INT8 event_type, /*type to wait for */
GRAPHICS_EVENT *out_event /*output event */
);
#endif

1009
viewer/grphics.cpp
View File

File diff suppressed because it is too large Load Diff

270
viewer/grphics.h
View File

@ -1,270 +0,0 @@
/**********************************************************************
* File: grphics.h (Formerly graphics.h)
* Description: Starbase stubs for connection to sbdaemon
* Author: Ray Smith
* Created: Wed May 16 08:34:32 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef GRPHICS_H
#define GRPHICS_H
//This is the main include file needed to get sbdaemon functionality
//TO BUILD A PROGRAM THAT USES SBDAEMON, YOU NEED:
//GRPHICS.CPP GRPHSHM.CPP AND EVNTLST.CPP.
//If you want to be able to wait for events, add evnts.cpp and include evnts.h.
//If you want to be able to show images, add showim.cpp and include showim.h.
#include "sbgdefs.h"
#include "sbgconst.h"
#define STATESIZE 13 //MUST equal EDGESTYLE+1
#define line_color_index(fd,index) fd->Line_color_index(index)
#define perimeter_color_index(fd,index) fd->Perimeter_color_index(index)
#define fill_color_index(fd,index) fd->Fill_color_index(index)
#define fill_color(fd,r,g,b) fd->Fill_color(r,g,b)
#define text_color_index(fd,index) fd->Text_color_index(index)
#define text_font_index(fd,index) fd->Text_font_index(index)
#define character_height(fd,height) fd->Character_height(height)
#define line_type(fd,style) fd->Line_type(style)
#define interior_style(fd,style,edged) fd->Interior_style(style,edged)
#define move2d(fd,x,y) fd->Move2d(x,y)
#define draw2d(fd,x,y) fd->Draw2d(x,y)
#define rectangle(fd,x1,y1,x2,y2) fd->Rectangle(x1,y1,x2,y2)
#define text2d(fd,x,y,string,xform,more) fd->Text2d(x,y,string,xform,more)
#define ellipse(fd,x_radius,y_radius,x_center,y_center,rotation) fd->Ellipse(x_radius,y_radius,x_center,y_center,rotation)
#define destroy_window(fd) fd->Destroy_window()
#define clear_view_surface(fd) fd->Clear_view_surface()
#define vdc_extent(fd,xmin,ymin,xmax,ymax) fd->Vdc_extent(xmin,ymin,xmax,ymax)
#define make_picture_current(fd) fd->Make_picture_current()
#define set_click_handler(fd,handler) fd->Set_click_handler(handler)
#define set_selection_handler(fd,handler) fd->Set_selection_handler(handler)
#define set_key_handler(fd,handler) fd->Set_key_handler(handler)
#define set_destroy_handler(fd,handler) fd->Set_destroy_handler(handler)
#define clear_event_queue(fd) fd->Clear_event_queue()
#define create_window(name,window_type,xpos,ypos,xsize,ysize,xmin,xmax,ymin,ymax,downon,moveon,upon,keyon) (*create_func)(name,window_type,xpos,ypos,xsize,ysize,xmin,xmax,ymin,ymax,downon,moveon,upon,keyon)
#define overlap_picture_ops(update) (*overlap_func)(update)
#define await_event(win,wait,type,event) (*await_event_func)(win,wait,type,event)
typedef void (*EVENT_HANDLER) (GRAPHICS_EVENT *);
/*name/title of window */
typedef WINDOW (*WINCREATEFUNC) (const char *name,
INT8 window_type, /*type of window */
INT16 xpos, /*coords of window */
INT16 ypos, /*coords of window */
INT16 xsize, /*size of window */
INT16 ysize, /*size of window */
float xmin, /*scrolling limits */
float xmax, /*to stop users */
float ymin, /*getting lost in */
float ymax, /*empty space */
BOOL8 downon, /*Events wanted */
BOOL8 moveon, BOOL8 upon, BOOL8 keyon);
extern WINCREATEFUNC create_func;
extern void (*overlap_func) (BOOL8);
extern WINDOW (*await_event_func) (WINDOW, BOOL8, INT8, GRAPHICS_EVENT *);
const int kInputSize = 16;
extern int input_unicode[kInputSize];
class DLLSYM WINFD
{
public:
//Constructors for WINFD are host dependent to match different
//implementations and are intended to be called only by
//create_window. Use create_window to make a window.
static WINDOW create( /*create a window */
const char *name, /*name/title of window */
INT8 window_type, /*type of window */
INT16 xpos, /*coords of window */
INT16 ypos, /*coords of window */
INT16 xsize, /*size of window */
INT16 ysize, /*size of window */
float xmin, /*scrolling limits */
float xmax, /*to stop users */
float ymin, /*getting lost in */
float ymax, /*empty space */
BOOL8 downon, /*Events wanted */
BOOL8 moveon,
BOOL8 upon,
BOOL8 keyon);
WINFD(); //constructor
virtual ~ WINFD ();
/*set line colour */
virtual void Line_color_index(COLOUR index); /*index to use */
/*set perimeter colour */
virtual void Perimeter_color_index(COLOUR index); /*index to use */
/*set fill colour */
virtual void Fill_color_index(COLOUR index); /*index to use */
virtual void Fill_color( /*set RGB fill colour */
UINT8 red,
UINT8 green,
UINT8 blue);
/*set marker colour */
virtual void Marker_color_index(COLOUR index); /*index to use */
/*set text colour */
virtual void Text_color_index(COLOUR index); /*index to use */
/*set text font */
virtual void Text_font_index(INT16 index); /*index to use */
/*set text height */
virtual void Character_height(float height); /*height to use */
virtual void Line_type( /*set line type */
INT16 style); /*style to use */
virtual void Marker_type( /*set marker type */
INT16 type); /*type to use */
virtual void Interior_style( /*set polygon style */
INT16 style, /*style to use */
INT16 edged); /*draw edge or not */
virtual void Marker_size( /*set marker size */
float size); /*size to use */
virtual void Move2d( /*move the pen */
float x, /*coords to move to */
float y); /*coords to move to */
virtual void Draw2d( /*draw the pen */
float x, /*coords to draw to */
float y); /*coords to draw to */
virtual void Rectangle( /*draw a rectangle */
float x1, /*coords to draw to */
float y1, /*coords to draw to */
float x2, /*coords to draw to */
float y2); /*coords to draw to */
virtual void Text_alignment( /*draw a rectangle */
INT32 h_select, //horizontal
INT32 v_select, //vertical
float horiz, /*coords to draw to */
float vert); /*coords to draw to */
virtual void Polyline2d ( /*draw a polyline */
float clist[], /*coordinate list */
INT16 numpts, /*number of coords */
INT16 flags); /*does it have move/draws */
virtual void Polygon2d ( /*draw a polygon */
float clist[], /*coordinate list */
INT16 numpts, /*number of coords */
INT16 flags); /*does it have move/draws */
virtual void Polymarker2d ( /*draw a polymarker */
float clist[], /*coordinate list */
INT16 numpts, /*number of coords */
INT16 flags); /*does it have move/draws */
virtual void Text2d( /*draw a text */
float x, /*coords of text */
float y,
const char *string, /*text to draw */
INT16 xform, /*transform */
INT16 more); /*more text? */
void Append_text( /*draw a text */
const char *string, /*text to draw */
INT16 xform, /*transform */
INT16 more); /*more text? */
virtual void Ellipse( /*draw a ellipse */
float x_radius, /*radii of ellipse */
float y_radius, /*radii of ellipse */
float x_center, /*centre of ellipse */
float y_center, /*centre of ellipse */
float rotation); /*rotation of ellipse */
virtual void Arc( /*draw a arc */
float x_radius, /*radii of arc */
float y_radius, /*radii of arc */
float x_center, /*centre of arc */
float y_center, /*centre of arc */
float start, /*ends of arc */
float stop, /*ends of arc */
float rotation, /*rotation of arc */
INT16 close_type); /*type of closure */
/*destroy a window */
virtual void Destroy_window();
/*clear window */
virtual void Clear_view_surface();
/*Mark need to recalc */
virtual void Re_compute_colourmap();
virtual void Vdc_extent( /*set window focus */
float xmin, /*min values */
float ymin, /*min values */
float xmax, /*max values */
float ymax); /*max values */
void Set_echo( /*set window echo */
ECHO_TYPE echo_type, //type of echo
float xorig, /*min values */
float yorig); /*min values */
/*update window */
virtual void Make_picture_current();
/*flush output */
friend void def_overlap_picture_ops(BOOL8 update); /*send make_ */
/*set line colour */
virtual void Synchronize_windows(WINDOW fd2); //other window
/* void Show_sub_image( //show rectangle
IMAGE* source, //source image
INT32 xstart, //start coords
INT32 ystart,
INT32 xext, //extent to copy
INT32 yext,
INT32 xdest, //destination coords
INT32 ydest);*/
INT16 get_fd() { //access
return fd;
}
void Set_selection_handler( //set callback function
EVENT_HANDLER handler); //handler function
void Set_key_handler( //set callback function
EVENT_HANDLER handler); //handler function
void Set_destroy_handler( //set callback function
EVENT_HANDLER handler); //handler function
void Set_click_handler( //set callback function
EVENT_HANDLER handler); //handler function
/*delete all events */
virtual void Clear_event_queue();
//internal maintenance functions
friend void add_event( /*add an event */
GRAPHICS_EVENT *event); /*event to add */
/*search for event */
friend GRAPHICS_EVENT *search_event_queue(INT16 &fd, /*queue to search */
INT8 event_type); /*type to search for */
/*search for event */
friend GRAPHICS_EVENT *search_single_queue(INT16 fd, /*queue to search */
INT8 event_type); /*type to search for */
protected:
EVENT_HANDLER click_handler; //callback function
//callback function
EVENT_HANDLER selection_handler;
EVENT_HANDLER key_handler; //callback function
//callback function
EVENT_HANDLER destroy_handler;
private:
void get_lock() {
} //wait for lock
void get_lock_for_draw() {
} //kill draw thread
void release_lock() {
} //let it go
void get_core_lock() {
} //wait for lock
void release_core_lock() {
} //let it go
INT16 fd; //"file descriptor"
BOOL8 used; /*true if fd in use */
BOOL8 downevent; /*event flags */
BOOL8 moveevent;
BOOL8 upevent;
BOOL8 keyevent;
GRAPHICS_EVENT *events; /*event queue */
GRAPHICS_EVENT *lastevent; /*event queue */
};
#endif

472
viewer/grphshm.cpp
View File

@ -1,472 +0,0 @@
/**********************************************************************
* File: grphshm.c (Formerly graphshm.c)
* Description: Functions for the shared memory sbdaemon connection.
* Author: Ray Smith
* Created: Thu May 24 14:09:38 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "mfcpch.h"
#include "evntlst.h"
#ifdef __UNIX__
#include <sys/ipc.h>
#include <sys/shm.h>
//#include <osfcn.h>
#include <errno.h>
//#include "pipes.h"
#include "fileerr.h"
//#include "grpherr.h"
//#include "basefile.h"
#include <unistd.h>
#elif defined(__MSW32__)
#include <io.h>
#include <fcntl.h>
#include <process.h>
#include <stdio.h>
#else
#endif
#include <string.h>
#include "grphics.h"
#include "grphshm.h"
#define EXTERN
EXTERN SHMINFO shminfo; /*shared memory */
EXTERN WINFD sbfds[MAXWINDOWS]; /*file descriptors */
EXTERN INT16 maxsbfd = 0; /*no of fds in use */
#ifdef __MSW32__
//event thread id
EXTERN DWORD event_id = (DWORD) - 1;
#endif
/**********************************************************************
* start_sbdaemon
*
* Creates the shared memory segment and starts up the sbdaemon telling
* it info about the segment. This only needs to be called once.
* It is called automatically from create_window at the first creation attempt.
**********************************************************************/
void start_sbdaemon() { /*start the daemon */
#if defined (__UNIX__) || defined(__MSW32__)
char *shmaddr; /*address to attach */
char *sbenv; /*SB_DISPLAY_ADDR */
INT32 sbaddr; /*starbase address */
INT32 wmshm; //windows shared mem
char arg1[MAX_PATH]; /*shmid argument */
char arg2[MAX_PATH]; /*shmstart argument */
char arg3[MAX_PATH]; /*shmsize argument */
const char *argv[5]; /*args of sbdaemon */
/*for pipe usage */
static char pipebuffer[PIPESIZE];
sbenv = getenv (SBADDR); /*get SB_DISPLAY_ADDR */
if (sbenv == NULL || sscanf (sbenv, INT32FORMAT, &sbaddr) != 1)
sbaddr = SBDEFAULT;
shmaddr = getenv (WMSHM);
if (shmaddr == NULL || sscanf (shmaddr, INT32FORMAT, &wmshm) != 1)
wmshm = WMSHMDEFAULT;
/*default address */
shmaddr = (char *) sbaddr - (wmshm + SHMSIZE + SHMOFFSET);
if (!remote_display (arg1)) {
shminfo.shmsize = SHMSIZE; /*size of segment */
#ifdef __UNIX__
shminfo.shmid = shmget (IPC_PRIVATE, SHMSIZE, USER_RW);
/*get shm segment */
// if (shminfo.shmid==-1)
// NO_SHM_SEGMENT.error("start_sbdaemon",ABORT,"Errno=%d",errno);
#ifdef hp9000s800
/*attach it */
shminfo.shmstart = shmat (shminfo.shmid, 0, 0);
if ((int) shminfo.shmstart == -1)
#else
/*attach it */
shminfo.shmstart = shmat (shminfo.shmid, shmaddr, 0);
// if (shminfo.shmstart!=shmaddr)
#endif
// SHM_ATTACH_FAILED.error("start_sbdaemon",ABORT,"Errno=%d",errno);
#else
SECURITY_ATTRIBUTES security;//for handles
security.nLength = sizeof (security);
security.lpSecurityDescriptor = NULL;
//make it inheritable
security.bInheritHandle = TRUE;
//anonymous
shminfo.shmid = CreateFileMapping ((HANDLE) 0xffffffff, &security, PAGE_READWRITE, 0, shminfo.shmsize + 3 * sizeof (INT32) + EVENTSIZE * sizeof (SBD_GRAPHICS_EVENT), NULL);
if (shminfo.shmid == NULL) {
shminfo.shmstart = NULL;
return; //quietly fail
}
shminfo.shmstart =
MapViewOfFile (shminfo.shmid, FILE_MAP_WRITE, 0, 0, 0);
if (shminfo.shmstart == NULL)
return;
EVENT_TAIL = 0;
EVENT_HEAD = 0;
#endif
/*set up args */
sprintf (arg1, "%d", shminfo.shmid);
sprintf (arg2, "%p", shminfo.shmstart);
sprintf (arg3, INT32FORMAT, shminfo.shmsize);
argv[0] = SBDAEMON; /*set up argv */
argv[1] = arg1;
argv[2] = arg2;
argv[3] = arg3;
argv[4] = NULL;
}
else {
shmaddr = NULL; //remote
fprintf (stderr, "start_sbdaemon:using %s to connect to machine %s\n",
REMSH, arg1);
#ifdef __UNIX__
shminfo.shmid = -1;
#else
shminfo.shmid = NULL;
#endif
/*not using shm */
shminfo.shmstart = pipebuffer;
shminfo.shmsize = PIPESIZE; /*size of pipe buffer */
#ifdef __UNIX__
/*command on host */
sprintf (arg2, "%s=0x%x; export %s; %s -1 0 " INT32FORMAT " %s", SBADDR, sbaddr, SBADDR, SBDAEMON, shminfo.shmsize, getenv (DISP));
#else
/*command on host */
sprintf (arg2, "%s -1 0 %d %s", SBDAEMON, shminfo.shmsize, getenv (DISP));
#endif
argv[0] = REMSH; /*set up argv */
argv[1] = arg1; /*host to use */
argv[2] = arg2;
argv[3] = NULL;
}
shminfo.usedsize = 0; /*none used yet */
#ifdef __UNIX__
// shminfo.pid=two_way_pipe(argv[0],argv,shminfo.fds); /*start daemon*/
#else
if (two_way_pipe (argv[0], argv, shminfo.fds) != 0) {
cleanup_sbdaemon();
}
else {
//anonymous
event_sem = CreateSemaphore (NULL, 1, 1, NULL);
//xiaofan
_beginthread (event_reader, 0, &shminfo.fds[INFD]);
}
#endif
#endif
}
/**********************************************************************
* cleanup_sbdaemon
*
* Free system resources for when the daemon has failed or been killed.
**********************************************************************/
void cleanup_sbdaemon() { /*forget about the daemon */
#ifdef __MSW32__
if (shminfo.fds[INFD] != NULL) {
CloseHandle (shminfo.fds[INFD]);
shminfo.fds[INFD] = 0;
}
if (shminfo.fds[OUTFD] != NULL) {
CloseHandle (shminfo.fds[OUTFD]);
shminfo.fds[OUTFD] = 0;
}
if (shminfo.shmstart != NULL) {
UnmapViewOfFile (shminfo.shmstart);
shminfo.shmstart = NULL;
}
if (shminfo.shmid != NULL) {
CloseHandle (shminfo.shmid);
shminfo.shmid = NULL;
}
if (event_sem != NULL) {
CloseHandle(event_sem);
event_sem = NULL;
}
#elif defined(__UNIX__)
if (shminfo.fds[INFD] > 0) {
close (shminfo.fds[INFD]);
shminfo.fds[INFD] = 0;
}
if (shminfo.fds[OUTFD] > 0) {
close (shminfo.fds[OUTFD]);
shminfo.fds[OUTFD] = 0;
}
shminfo.shmstart = NULL;
#endif
}
/**********************************************************************
* remote_display
*
* Returns TRUE if the DISPLAY environment variable points to a
* Remote display, and sets the name to the name of the host.
* Otherwise, returns FALSE.
**********************************************************************/
BOOL8 remote_display( //check for remote
char *name //name of host
) {
#if defined (__UNIX__) || defined(__MSW32__)
char *xenv; /*DISPLAY environ */
char *nameend; //end of name
#ifdef __UNIX__
char thishost[MAX_PATH]; //current host
#endif
xenv = getenv (DISP); /*get display variable */
if (xenv != NULL) {
strcpy(name, xenv);
nameend = strchr (name, ':');
if (nameend != NULL)
*nameend = '\0'; /*chop display off */
nameend = strchr (name, '.');
if (nameend != NULL)
*nameend = '\0'; /*chop resolv off */
#ifdef __UNIX__
if (strcmp (name, LOCAL1) && strcmp (name, LOCAL2)
&& gethostname (thishost, MAX_PATH) >= 0) {
nameend = strchr (thishost, '.');
if (nameend != NULL)
*nameend = '\0'; /*chop resolv off */
if (strcmp (name, thishost)) {
return TRUE;
}
}
#else
return TRUE;
#endif
}
#endif
return FALSE;
}
/**********************************************************************
* getshm
*
* Get the next element of the shared memory. If there is no more room
* in the segment, kick the daemon to get it to empty it out and then
* restart the buffer once it acknowledges the cleanout.
**********************************************************************/
DLLSYM void *getshm( /*get memory */
INT32 size /*required size */
) {
void *segment; /*return segment */
if (shminfo.shmstart == NULL)
return NULL; //no daemon connection
size = (size + 3) & ~3;
if (size > shminfo.shmsize)
return NULL;
/*too full? */
if (shminfo.usedsize + size > shminfo.shmsize
|| shminfo.usedsize < 0) { /*or read pending */
kick_daemon(AWAIT_BUFFER); /*get it to read */
}
/*address of segment */
segment = (char *) shminfo.shmstart + shminfo.usedsize;
shminfo.usedsize += size; /*sum used sizes */
return segment;
}
/**********************************************************************
* kick_daemon
*
* Tell the daemon to read the shared memory and perform all the
* operations in it. This function blocks until the daemon has
* emptied the queue.
**********************************************************************/
void kick_daemon( /*empty queue */
INT8 mode /*control mode */
) {
#ifndef __MAC__
SBD_GRAPHICS_EVENT event; /*event from daemon */
GRAPHICS_EVENT real_event; //converted format
#ifdef __MSW32__
unsigned long nwrite;
unsigned long nread; //bytes read
char pipe_char[2]; //char from pipe
INT32 pipe_index; //index to event queue
#endif
static INT16 reads_pending = 0;/*acknowledges pending */
if (mode == COUNT_READS) {
lock_events();
reads_pending--; /*got a read */
unlock_events();
return;
}
if (shminfo.shmstart == NULL)
return; //no connection
if (shminfo.usedsize > 0) {
#ifdef __UNIX__
if (write
(shminfo.fds[OUTFD], (const char *) &shminfo.usedsize,
sizeof (INT32)) != sizeof (INT32))
WRITEFAILED.error ("kick_daemon", EXIT, "sbdaemon pipe");
#else
PRIMITIVES = shminfo.usedsize;
if (WriteFile (shminfo.fds[OUTFD], "xx", 2, &nwrite, NULL) == 0
|| nwrite != 2) {
cleanup_sbdaemon();
return;
}
#endif
#ifdef __UNIX__
if (shminfo.shmid < 0) {
if (write (shminfo.fds[OUTFD], (const char *) shminfo.shmstart,
shminfo.usedsize) != shminfo.usedsize)
WRITEFAILED.error ("kick_daemon", EXIT, "sbdaemon pipe");
#else
if (shminfo.shmid == NULL) {
if (WriteFile (shminfo.fds[OUTFD], (const char *) shminfo.shmstart,
shminfo.usedsize, &nwrite, NULL) == 0
|| nwrite != (UINT32) shminfo.usedsize) {
cleanup_sbdaemon();
return;
}
#endif
shminfo.usedsize = 0; /*can use it now */
}
else
shminfo.usedsize = -1; /*need to wait */
lock_events();
reads_pending++; /*acknowledges due */
unlock_events();
}
if (mode == FLUSH_IN || reads_pending > MAX_PENDING || mode == AWAIT_BUFFER
#ifdef __UNIX__
&& shminfo.shmid < 0)
#else
&& shminfo.shmid != NULL)
#endif
{
while (reads_pending > 0) {
#ifdef __MSW32__
if (event_id == GetCurrentThreadId ()) {
if (ReadFile (shminfo.fds[INFD], pipe_char, 2, &nread, NULL) != 0
&& nread == 2) {
pipe_index = EVENT_HEAD;
event = EVENT_INDEX (pipe_index);
pipe_index++;
if (pipe_index >= EVENTSIZE)
pipe_index = 0;
EVENT_HEAD = pipe_index;
#endif
#ifdef __UNIX__
if (read
(shminfo.fds[INFD], &event,
sizeof (SBD_GRAPHICS_EVENT)) !=
sizeof (SBD_GRAPHICS_EVENT))
READFAILED.error ("kick_daemon", EXIT, "sbdaemon pipe");
#endif
if (event.type != QUEUE_CLEAR) {
real_event.fildes = event.fd;
real_event.type = event.type;
real_event.key = event.key;
real_event.x = event.x;
real_event.y = event.y;
real_event.next = NULL;
/*add event to queue */
add_event(&real_event);
}
else
reads_pending--; /*got acknowledge */
#ifdef __MSW32__
}
}
else
Sleep (50);
#endif
}
if (shminfo.usedsize < 0) //must be reentrant
shminfo.usedsize = 0; /*none used now */
}
#endif
}
#ifdef __MSW32__
/**********************************************************************
* two_way_pipe
*
* Open the process and connect a 2 way pipe to its stdin and stdout.
**********************************************************************/
int
two_way_pipe ( //do one file
const char *file, //program to run
const char *argv[], //args to execvp
HANDLE fds[] //output fds
) {
int argind; //argument index
HANDLE infds[2]; //input fds
HANDLE outfds[2]; //output fds
HANDLE sends[2]; //fds for child
HANDLE process; //current process
STARTUPINFO start_info; //start information
//process info
PROCESS_INFORMATION proc_info;
char cmd[MAX_PATH * 2]; //final command line
if (CreatePipe (&infds[0], &infds[1], NULL, PIPESIZE) == 0
|| CreatePipe (&outfds[0], &outfds[1], NULL, PIPESIZE) == 0)
return -1;
/* if (_pipe(infds,PIPESIZE,_O_BINARY)<0
|| _pipe(outfds,PIPESIZE,_O_BINARY)<0)
return -1; */
process = GetCurrentProcess ();
if (DuplicateHandle (process, outfds[0],
process, &sends[0], GENERIC_READ, TRUE,
DUPLICATE_CLOSE_SOURCE) == 0)
return -1;
if (DuplicateHandle (process, infds[1],
process, &sends[1], GENERIC_WRITE, TRUE,
DUPLICATE_CLOSE_SOURCE) == 0)
return -1;
cmd[0] = '\0';
for (argind = 0; argv[argind] != NULL; argind++) {
if (argind != 0)
strcat (cmd, " ");
strcat (cmd, argv[argind]);
}
GetStartupInfo(&start_info);
start_info.wShowWindow = FALSE;
start_info.hStdInput = sends[0];
start_info.hStdOutput = sends[1];
start_info.dwFlags = STARTF_USESTDHANDLES;
if (!CreateProcess (NULL, (char *) cmd, NULL, NULL, TRUE,
CREATE_NO_WINDOW | CREATE_SUSPENDED, NULL, NULL,
&start_info, &proc_info))
return -1;
CloseHandle (sends[0]);
CloseHandle (sends[1]);
CloseHandle (proc_info.hProcess);
ResumeThread (proc_info.hThread);
CloseHandle (proc_info.hThread);
fds[INFD] = infds[0];
fds[OUTFD] = outfds[1];
return 0;
}
#endif

74
viewer/grphshm.h
View File

@ -1,74 +0,0 @@
/**********************************************************************
* File: grphshm.h (Formerly graphshm.h)
* Description: Header for graphics shared memory functions.
* Author: Ray Smith
* Created: Thu May 24 15:29:28 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef GRPHSHM_H
#define GRPHSHM_H
#include "sbgtypes.h"
#include "grphics.h"
#define SHMSIZE (65536*8) /*shm segment size */
#define PIPESIZE 8192 /*pipe bufer size */
#define USER_RW 0600 /*permission flags */
/*starbase environ */
#define SBADDR "SB_DISPLAY_ADDR"
#define WMSHM "WMSHMSPC" /*shared mem size */
#define WMSHMDEFAULT 0x200000 /*default value */
#define SBDEFAULT 0x0b00000 /*default ADDR */
#define SHMOFFSET 0x200000 /*offset before sbaddr */
#define MAXDATA 0x1000000 /*default data seg size */
#define SBDAEMON "sbdaemon"
#define REMSH "remsh" /*command for remote use */
#define DISP "DISPLAY" /*environ var */
#define LOCAL1 "local" /*possible values */
#define LOCAL2 "unix" /*of DISPLAY */
#define FLUSH_OUT 0 /*kick_daemon commands */
#define FLUSH_IN 1
#define AWAIT_BUFFER 2 /*wait for free buffer */
#define COUNT_READS 3 /*count a queue clear */
#define MAX_PENDING 255 /*max pending reads */
extern SHMINFO shminfo; /*shared memory */
extern WINFD sbfds[MAXWINDOWS]; /*file descriptors */
extern INT16 maxsbfd;
#ifdef __MSW32__
extern DWORD event_id; //event thread id
#endif
void start_sbdaemon(); /*start the daemon */
void cleanup_sbdaemon(); /*forget about the daemon */
BOOL8 remote_display( //check for remote
char *name //name of host
);
DLLSYM void *getshm( /*get memory */
INT32 size /*required size */
);
void kick_daemon( /*empty queue */
INT8 mode /*control mode */
);
#ifdef __MSW32__
int two_way_pipe ( //do one file
const char *file, //program to run
const char *argv[], //args to execvp
HANDLE fds[] //output fds
);
#endif
#endif

135
viewer/sbgconst.h
View File

@ -1,135 +0,0 @@
/**********************************************************************
* File: sbgconst.h (Formerly sbconst.h)
* Description: Header file of constants needed by graphics code.
* Author: Ray Smith
* Created: Thu May 24 14:19:43 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef SBGCONST_H
#define SBGCONST_H
//This file contains all the symbols and constants that the user sees
//that are not defined by Starbase.
#include "host.h"
#define WINDOWNAMESIZE 13 /*max size of name */
#define MAXWINDOWS 64 /*max allowed windows */
#define MAXWINDOWNAME 1024 /*max name length */
#define NO_WINDOW 0 /*no legal window */
#define SMDWINDOW 0 /*use smd, no window */
#define SCROLLINGWIN 1 /*scrolling window */
#define FULLSIZEWIN 2 /*non-scrolling window */
#define DCWIN 3 /*dc drawing only */
#define M_DOT 0 /*marker_types */
#define M_PLUS 1 /*starbase markers */
#define M_ASTERISK 2
#define M_CIRCLE 3
#define M_CROSS 4
#define M_TRIANGLE 5
#define M_SQUARE 6
#define M_DIAMOND 7
#define M_CROSSED_SQUARE 8
class WINFD;
typedef WINFD *WINDOW; //compatible with old code
typedef enum {
BLACK,
WHITE,
RED,
YELLOW,
GREEN,
CYAN,
BLUE,
MAGENTA,
AQUAMARINE,
DARK_SLATE_BLUE,
LIGHT_BLUE,
MEDIUM_BLUE,
MIDNIGHT_BLUE,
NAVY_BLUE,
SKY_BLUE,
SLATE_BLUE,
STEEL_BLUE,
CORAL,
BROWN,
SANDY_BROWN,
GOLD,
GOLDENROD,
DARK_GREEN,
DARK_OLIVE_GREEN,
FOREST_GREEN,
LIME_GREEN,
PALE_GREEN,
YELLOW_GREEN,
LIGHT_GREY,
DARK_SLATE_GREY,
DIM_GREY,
GREY,
KHAKI,
MAROON,
ORANGE,
ORCHID,
PINK,
PLUM,
INDIAN_RED,
ORANGE_RED,
VIOLET_RED,
SALMON,
TAN,
TURQUOISE,
DARK_TURQUOISE,
VIOLET,
WHEAT,
GREEN_YELLOW
} COLOUR; /*starbase colours */
enum ECHO_TYPE
{
NO_ECHO,
BEST_ECHO,
CROSS_HAIR_ECHO,
SMALL_X_ECHO,
RUBBER_LINE_ECHO,
RUBBER_BOX_ECHO,
ALPHA_ECHO
};
/*Event types*/
#define QUEUE_CLEAR 0 /*queue is empty */
#define DOWN_EVENT 1 /*button press */
#define MOVE_EVENT 2 /*pointer move */
#define UP_EVENT 3 /*button release */
#define KEYPRESS_EVENT 4 /*key pressed */
#define SELECT_EVENT 5 /*press-release pair */
#define ANY_EVENT 6 /*any type */
#define DESTROY_EVENT 7
typedef struct graphicsevent
{
struct graphicsevent *next; /*next event */
WINDOW fd; //structure of window
INT16 fildes; //unix only
INT8 type; /*event type */
char key; /*keypress */
float x, y; /*position of event */
float xmax, ymax; //for selection
} GRAPHICS_EVENT; /*event type */
typedef void (*EVENT_HANDLER) (GRAPHICS_EVENT *);
#endif

421
viewer/sbgdefs.h
View File

@ -1,421 +0,0 @@
/* STARBASE_ID:sb.c.h 286.1 07/06/89 22:09:56 */
/* (c) Copyright Hewlett-Packard Company, 1985.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
All rights are reserved. Copying or other
reproduction of this program except for archival
purposes is prohibited without the prior
written consent of Hewlett-Packard Company.
RESTRICTED RIGHTS LEGEND
Use, duplication, or disclosure by the U.S. Government
is subject to restrictions as set forth in
subdivision (b) (3) (ii) of the Rights in Technical
Data and Computer Software clause at
52.227-7013.
HEWLETT-PACKARD COMPANY
Fort Collins, Colorado */
/************************************************************************
*
* definitions and types to be included with STARBASE application
* programs
*
***********************************************************************/
#ifndef _STARBASE_INCLUDED /* allow multiple inclusions */
#define _STARBASE_INCLUDED
/* kinds of graphics devices */
#define OUTDEV 0
#define INDEV 1
#define OUTINDEV 2
#define OUTMETA 3
#define INMETA 4
/* clear control parameters */
#define CLEAR_VDC_EXTENT 1
#define CLEAR_VIEWPORT 17
#define CLEAR_CLIP_RECTANGLE 33
#define CLEAR_DISPLAY_SURFACE 65
#define CLEAR_ALL_BANKS 128
#define CLEAR_ZBUFFER 256
/* clip control parameters */
#define CLIP_TO_RECT 1
#define CLIP_TO_VDC 2
#define CLIP_OFF 3
#define CLIP_TO_VIEWPORT 4
/* gopen open_mode parameter masks */
#define SPOOLED 0x01 /* if this bit is on, output is spooled */
//#define INIT 0x02 /* if this bit is on, device initialization occurs */
#define THREE_D 0x04 /* if this bit is on, all transformations are 3D */
#define RESET_DEVICE 0x08 /* if this bit is on, hard reset including p1 & p2 */
#define MODEL_XFORM 0x10 /* if this bit is on, matrix stack in modeling mode */
#define INT_XFORM 0x20 /* if this bit is on, matrix stack in modeling mode */
#define FLOAT_XFORM 0x40 /* if this bit is on, matrix stack in modeling mode */
/* color map modes set with shade_mode */
#define CMAP_NORMAL 0
#define CMAP_MONOTONIC 1
#define CMAP_FULL 4
/* double_buffer mode used to draw into the same buffer that is displayed */
#define DFRONT 4
/* double_buffer mode used to not clear buffer when switched */
#define SUPPRESS_CLEAR 8
/* light source types set with light_source */
#define DIRECTIONAL 0
#define POSITIONAL 1
#define ATTEN_LIGHT 2
#define SPOT_LIGHT 4
#define CONE_LIGHT 8
/* vertex orders set with vertex_format */
#define CLOCKWISE 0x0000
#define COUNTER_CLOCKWISE 0x0001
#define UNIT_NORMALS 0x0200
/* set p1 p2 units */
#define FRACTIONAL 0
#define METRIC 1
/* mapping modes */
#define ISOTROPIC 0
#define DISTORT 1
/* Starbase linetypes */
#define SOLID 0
#define DASH 1
#define DOT 2
#define DASH_DOT 3
#define DASH_DOT_DOT 4
#define LONG_DASH 5
#define CENTER_DASH 6
#define CENTER_DASH_DASH 7
/* wide endpoint types */
#define SQUARE 0
#define ROUNDED 1
/* depth cue models */
#define DC_MIN 2
#define DC_COLOR 4
/* distance modes for line_width, hatch_spacing */
#define VDC_UNITS 0
#define WC_UNITS 1
#define MC_UNITS WC_UNITS
#define DC_UNITS 2
/* polygon interior styles */
#define INT_HOLLOW 0
#define INT_SOLID 1
#define INT_PATTERN 2
#define INT_HATCH 3
#define INT_OUTLINE 4
#define INT_POINT 5
/* Matrix concatenation types */
#define PRE 0
#define POST 1
#define REPLACE 0
#define PUSH 1
/* Viewing matrix change types */
#define REPLACE_VW 0
#define PRE_CONCAT_VW 1
#define POST_CONCAT_VW 2
/* character switching modes */
#define ISO_7BIT 0
#define ISO_8BIT 1
#define HP_8BIT 2
/* text precision types */
#define STRING_TEXT 0
#define CHARACTER_TEXT 1
#define STROKE_TEXT 2
/* text transformation types */
#define VDC_TEXT 0
#define WORLD_COORDINATE_TEXT 1
#define TOS_TEXT 2
#define ANNOTATION_TEXT 3
/* text alignment enumerated types */
#define TA_LEFT 0
#define SB_TA_CENTER 1
#define TA_RIGHT 2
#define TA_CONTINUOUS_HORIZONTAL 3
#define TA_NORMAL_HORIZONTAL 4
#define TA_TOP 0
#define TA_CAP 1
#define TA_HALF 2
#define TA_BASE 3
#define SB_TA_BOTTOM 4
#define TA_CONTINUOUS_VERTICAL 5
#define TA_NORMAL_VERTICAL 6
/* character path and line path enumerated types */
#define PATH_RIGHT 0
#define PATH_LEFT 1
#define PATH_UP 2
#define PATH_DOWN 3
/* input device class enumerated types */
#define ALL 0
#define LOCATOR 1
#define CHOICE 4
/* event queue states */
#define EMPTY_NO_OVERFLOW 0
#define EMPTY_OVERFLOW 1
#define NOT_EMPTY_NO_OVERFLOW 2
#define NOT_EMPTY_OVERFLOW 3
/* event message link enumerated types */
#define SIMULTANEOUS_EVENT_FOLLOWS 0
#define SINGLE_EVENT 1
/* gerr printing flags */
#define NO_ERROR_PRINTING 0
#define PRINT_ERRORS 1
#define PRINT_WARNINGS 2
/* arc close_types */
#define NO_CHORD 0
#define PIE 1
#define CHORD 2
/* spline orders and rationalities */
#define NONRATIONAL 0
//#define RATIONAL 1
#define LINEAR 2
#define QUADRATIC 3
#define CUBIC 4
#define QUARTIC 5
#define QUINTIC 6
#define DC_VALUES 0
#define VDC_VALUES 2
#define STEP_SIZE 3
/* transform_point modes */
#define MC_TO_WC 0
#define MC_TO_WORLD 0
#define MC_TO_VDC 1
#define WC_TO_VDC 2
#define WORLD_TO_VDC 2
#define WC_TO_MC 3
#define WORLD_TO_MC 3
#define VDC_TO_MC 4
#define VDC_TO_WC 5
#define VDC_TO_WORLD 5
#define INTVDC_TO_DC 6
#define DC_TO_INTVDC 7
/* view_camera projection types */
#define CAM_PERSPECTIVE 0.0
#define CAM_PARALLEL 1.0
/* plane printing modes */
#define ALL_PLANES -1
#define PIXEL_MAJOR -1
#define PLANE_MAJOR -2
/* hatch types */
#define PARALLEL_HATCH 0
#define CROSSHATCH 1
/* highlight attribute types */
#define HL_COLOR 1
#define HL_STYLE 2
/* Hardware cursor control types */
#define REQUEST_HW_CURSOR 1
#define REQUEST_SW_CURSOR 2
#define FORCE_HW_CURSOR 3
#define REQUEST_HW_ECHO 1
#define REQUEST_SW_ECHO 2
#define FORCE_HW_ECHO 3
/* cgm encoding types */
#define CGM_BINARY 1
#define CGM_CHARACTER 2
#define CGM_CLEAR_TEXT 3
/* GLOBAL gescapes */
#define SWITCH_SEMAPHORE 0
#define READ_COLOR_MAP 1
#define BLINK_PLANES 2
#define BLINK_INDEX 3
/* GLOBAL raster gescapes */
#define R_GET_FRAME_BUFFER 20
#define R_LOCK_DEVICE 21
#define R_UNLOCK_DEVICE 22
#define R_GET_WINDOW_INFO 23
#define R_FULL_FRAME_BUFFER 24
#define R_ALLOC_OFFSCREEN 25
#define R_FREE_OFFSCREEN 26
#define R_BIT_MODE 27
#define R_BIT_MASK 28
#define R_DEF_FILL_PAT 29
#define R_OVERLAY_ECHO 30
#define R_OV_ECHO_COLORS 31
#define R_DEF_ECHO_TRANS 32
#define R_TRANSPARENCY_INDEX 33
#define R_LINE_TYPE 34
#define R_ECHO_FG_BG_COLORS 35
#define R_DMA_MODE 36
#define R_ECHO_MASK 37
#define R_ECHO_CONTROL 38
#define R_OFFSCREEN_ALLOC 1106
#define R_OFFSCREEN_FREE 1107
/* HPGL gescapes */
#define HPGL_WRITE_BUFFER 100
#define HPGL_SET_PEN_NUM 101
#define HPGL_SET_PEN_SPEED 102
#define HPGL_SET_PEN_WIDTH 103
#define HPGL_READ_BUFFER 104
/* HPGL2 gescapes */
#define HPGL2_SET_MEDIA_TYPE 105
#define HPGL2_LOGICAL_PEN_WIDTH 106
#define HPGL2_CUTTER_CONTROL 107
#define HPGL2_REPLOT 108
#define HPGL2_FONT_TYPEFACE 109
#define HPGL2_ADAPTIVE_LINES 110
#define HPGL2_SET_QUALITY 111
#define HPGL2_SET_CMAP_SIZE 112
#define HPGL2_FONT_WEIGHT 113
#define HPGL2_FONT_POSTURE 114
/* HP26XX gescapes */
#define HP26_PRINT_ESC 200
#define HPTERM_PRINT_ESC 200
#define HPTERM_640x400 201
/* 98700 gescapes */
#define GB_NONE 300
/* 98710 gescapes */
#define GA_NONE 400
/* 300l gescapes */
#define TC_HALF_PIXEL 500
/* HIL and keyboard gescapes */
#define ENABLE_AUTO_PROMPT 600
#define DISABLE_AUTO_PROMPT 601
#define PROMPT_ON 602
#define PROMPT_OFF 603
#define TRIGGER_ON_RELEASE 604
#define IGNORE_RELEASE 605
#define REPORT_PROXIMITY 606
#define IGNORE_PROXIMITY 607
#define ENABLE_ACKNOWLEDGE 608
#define DISABLE_ACKNOWLEDGE 609
#define SET_ACCELERATION 610 /* hil acceleration multiplier */
/* GKSM gescapes */
#define GKSM_WRITE_ITEM 700
#define GKSM_GET_ITEM_TYPE 701
#define GKSM_READ_ITEM 702
#define GKSM_SKIP_ITEM 703
#define GKSM_INQ_COLOR_NDCES 704
#define GKSM_INQ_PAT_REP 705
/* 98721 gescapes */
#define TRANSPARENCY 800
#define ZBUFFER_ALLOC 801
#define LS_OVERFLOW_CONTROL 802
#define PATTERN_FILL 803
#define ZWRITE_ENABLE 804
#define ZSTATE_SAVE 805
#define ZSTATE_RESTORE 806
/* SMDpixel and SMDpixel3 gescapes */
#define SMD_SUPPLY_MEM_BUFF 900
#define SMD_GET_MEM_REQUIRED 901
#define SMD_DEFINE_XY 902
#define SMD_DEFINE_DEPTH 903
#define SMD_ALLOCATE_MEMORY 904
/* Xn gescapes */
#define XN_INPUT_RAW 1000
/* raw mode (TRUE) returns LK201 keycodes
cooked mode (FALSE) returns ASCII */
#define XN_KEY_RELEASE 1001 /* turn on/off key release events */
#define XN_BUTTON_RELEASE 1002 /* turn on/off button release events */
/* 98549/49/50/56 gescapes */
#define GR2D_MASK_ENABLE 1100
#define GR2D_MASK_RULE 1101
#define GR2D_DEF_MASK 1102
#define GR2D_FILL_PATTERN 1103
#define GR2D_OVERLAY_TRANSPARENT 1104
#define GR2D_REPLICATE 1105
#define GR2D_ALLOC_OFFSCREEN 1106
#define GR2D_FREE_OFFSCREEN 1107
#define GR2D_PLANE_MASK 1108
#define GR2D_INQ_CLIST_ADDR 1109
#define GR2D_LOAD_CLIST 1110
#define GR2D_CONVEX_POLYGONS 1112
/* hp98730/31 driver gescapes */
#define PAN_AND_ZOOM 1200
#define OVERLAY_BLEND 1201
#define IMAGE_BLEND 1202
#define SET_BANK_CMAP 1203
#define GAMMA_CORRECTION 1204
#define INQ_GAMMA_CORRECTION 1205
#define FULL_COLOR_INDEX 1206
#define POLYGON_TRANSPARENCY 1207
#define CLIP_OVERFLOW 1208
/* hp98704/05 gescapes */
#define SET_REPLACEMENT_RULE 1250
/* hpcgm driver gescapes */
#define CGMESC_ENCODING 1300
#define CGMESC_ESCAPE_ELT 1301
#define CGMESC_MET_NAME 1302
#define CGMESC_PIC_NAME 1303
#define CGMESC_FONT_IX 1304
#define CGMESC_MESSAGE 1305
#define CGMESC_APPL_DATA 1306
#define CGMESC_VDC_PREC 1307
#define CGMESC_TOP_MODE 1308
typedef union
{
int i[64];
float f[64];
char c[255];
} gescape_arg;
typedef struct
{
float refx, refy, refz;
float camx, camy, camz;
float upx, upy, upz;
float field_of_view;
float front, back;
float projection;
} camera_arg;
#endif /* _STARBASE_INCLUDED */

248
viewer/sbgtypes.h
View File

@ -1,248 +0,0 @@
/**********************************************************************
* File: sbgtypes.h (Formerly sbtypes.h)
* Description: Structures for the Starbase/X daemon interface.
* Author: Ray Smith
* Created: Wed May 16 09:26:35 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef SBGTYPES_H
#define SBGTYPES_H
//This file contains all the symbols and types that are not of concern
//to the user, but are common to both the client and the sbdaemon side.
#include "sbgconst.h"
#ifdef __UNIX__
#include <sys/types.h>
#endif
#define CHECK_TIME 1000 /*1 millisecond */
#define AWAIT_TIME 999999 /*1 second */
#define INFD 0 /*index to fds */
#define OUTFD 1 /*for read/write */
#define EVENTSIZE 16 //event buffer
#define PRIMITIVES (*(INT32*)((char*)shminfo.shmstart+shminfo.shmsize))
#define EVENT_TAIL (*(INT32*)((char*)shminfo.shmstart+shminfo.shmsize+sizeof(INT32)))
#define EVENT_HEAD (*(INT32*)((char*)shminfo.shmstart+shminfo.shmsize+2*sizeof(INT32)))
#define EVENT_INDEX(index) (((SBD_GRAPHICS_EVENT*)((char*)shminfo.shmstart+shminfo.shmsize+3*sizeof(INT32)))[index])
typedef enum {
LINECOLOUR, /*line_color_index */
PERIMETERCOLOUR, /*perimeter_color_index */
FILLCOLOUR, /*fill_color_index */
MARKERCOLOUR, /*marker_color_index */
TEXTCOLOUR, /*text_color_index */
TEXTFONT, /*text_font_index */
CHARHEIGHT, /*character_height */
LINETYPE, /*line_type */
MARKERTYPE, /*marker_type */
MARKERSIZE, /*marker_size */
MARKERMODE, /*mode in markersize */
INTERIORSTYLE, /*interior_style */
EDGESTYLE, /*edge in interior_style */
MOVE2D, /*move2d */
DRAW2D, /*draw2d */
RECTANGLE, /*rectangle */
TEXT_ALIGNMENT, //alginment
POLYLINE2D, /*polyline2d */
POLYGON2D, /*polygon2d */
POLYMARKER2D, /*polymarker2d */
TEXT2D, /*text2d */
APPENDTEXT, /*append_text */
ELLIPSE, /*ellipse */
ARC, /*arc */
SHOWIMAGE, /*display image */
SHOWLINE, /*send image line */
CREATE, /*create_window */
DESTROY, /*destroy_window */
CLEAR, /*clear_view_surface */
VDCEXTENT, /*vdc_extent */
MAKECURRENT, /*make_picture_current */
SETSIGNALS, //add callback
SETECHO, //change cursor
SYNCWIN, //sychronize
RE_COMP_COLMAP //Re-compute colourmap
} CALL_TYPE; /*type of call */
typedef union
{
INT16 fd; /*input fd */
void *next; /*turns to link */
} HEADUNION; /*header of structure */
typedef union
{
float f; /*parameter union */
INT32 i; /*to reduce structures */
} PARAMUNION;
typedef struct
{
PARAMUNION p; /*single parameter */
} ONEPARAM;
typedef struct
{
PARAMUNION p[2]; /*two params */
} TWOPARAMS;
typedef struct
{
PARAMUNION p[4]; /*4 params */
} FOURPARAMS;
typedef struct
{
PARAMUNION p[8]; /*8 params */
} EIGHTPARAMS;
typedef struct
{
HEADUNION header; /*fd/next op */
CALL_TYPE type; /*call type */
ONEPARAM param; /*single parameter */
} ONEOP;
typedef struct
{
HEADUNION header; /*fd/next op */
CALL_TYPE type; /*call type */
TWOPARAMS param; /*single parameter */
} TWOOP;
typedef struct
{
HEADUNION header; /*fd/next op */
CALL_TYPE type; /*call type */
FOURPARAMS param; /*single parameter */
} FOUROP;
typedef struct
{
HEADUNION header; /*fd/next op */
CALL_TYPE type; /*call type */
EIGHTPARAMS param; /*single parameter */
} EIGHTOP;
typedef struct
{
float *clist; /*coord list */
INT32 numpts; /*number of coords */
INT32 flags; /*move/draws on/off */
} POLYPARAM; /*polygon params */
typedef struct
{
HEADUNION header; /*fd/next */
CALL_TYPE type; /*operator type */
POLYPARAM param; /*parameters */
float polyxmin, polyxmax; /*bounding box */
float polyymin, polyymax; /*of polyline */
float clist[1]; /*place holder */
} POLYOP; /*poly line/marker */
typedef struct
{
float x, y; /*coords of text */
char *string; /*string to draw */
INT32 xform; /*coord transform */
INT32 more; /*any more text */
} TEXTPARAM; /*text parameters */
typedef struct
{
char *string; /*string to draw */
INT32 xform; /*coord transform */
INT32 more; /*any more text */
} APPENDPARAM; /*text parameters */
typedef struct
{
HEADUNION header; /*fd/next */
CALL_TYPE type; /*operator type */
TEXTPARAM param; /*parameters */
char chars[4]; /*place holder */
} TEXTOP; /*poly line/marker */
typedef struct
{
HEADUNION header; /*fd/next */
CALL_TYPE type; /*operator type */
APPENDPARAM param; /*parameters */
char chars[4]; /*place holder */
} APPENDOP; /*poly line/marker */
typedef struct
{
HEADUNION header; /*fd/next */
CALL_TYPE type; /*operator type */
INT32 size; /*size of structure */
UINT8 line[2]; /*image line */
} IMAGEOP; /*image passing */
typedef struct
{
HEADUNION header; /*fd/next */
CALL_TYPE type; /*operator type */
INT16 xpos, ypos; /*initial position */
INT16 xsize, ysize; /*initial size */
float xmin, xmax; /*scrolling limits */
float ymin, ymax;
BOOL8 downon; /*events required */
BOOL8 moveon;
BOOL8 upon;
BOOL8 keyon;
INT32 window_type; /*false for SMD */
char name[MAXWINDOWNAME]; /*name of window */
} CREATEOP;
typedef struct
{
#ifdef __UNIX__
int fds[2]; /*I/O files */
int shmid; /*shared memory id */
#else
#ifdef __PCDEMON__
int fds[2]; /*I/O files */
#else
HANDLE fds[2]; /*I/O files */
#endif
HANDLE shmid; //handle to it
#endif
void *shmstart; /*addr of shm seg */
INT32 usedsize; /*amount used */
INT32 shmsize; /*size of shm seg */
#ifdef __UNIX
pid_t pid; /*child process id */
#endif
} SHMINFO; /*shared memory info */
typedef struct sbdgraphicsevent
{
struct sbdgraphicsevent *next; /*next event */
INT16 fd; //unix only
INT8 type; /*event type */
char key; /*keypress */
float x, y; /*position of event */
} SBD_GRAPHICS_EVENT; /*event type */
//typedef void (*SBFUNC)(WINFD*,...); /*starbase function*/
typedef void (*DELFUNC) (void *, INT32);
/*deletion function */
typedef INT16 SBDWINDOW;
#endif

751
viewer/scrollview.cpp Normal file
View File

@ -0,0 +1,751 @@
///////////////////////////////////////////////////////////////////////
// File: scrollview.cc
// Description: ScrollView
// Author: Joern Wanke
// Created: Thu Nov 29 2007
//
// (C) Copyright 2007, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
//
// This class contains the main ScrollView-logic,
// e.g. parsing & sending messages, images etc.
const bool kDebugMode = false;
const int kSvPort = 8461;
const int kMaxMsgSize = 4096;
#include "scrollview.h"
#include <stdarg.h>
#include <iostream>
#include <map>
#include <utility>
#include "svutil.h"
#ifdef HAVE_LIBLEPT
#include "allheaders.h"
#endif
// A map between the window IDs and their corresponding pointers.
static std::map<int, ScrollView*> svmap;
// A map of all semaphores waiting for a specific event on a specific window.
static std::map<std::pair<ScrollView*, SVEventType>,
std::pair<SVSemaphore*, SVEvent*> > waiting_for_events;
SVMutex* mutex_waiting;
SVEvent* SVEvent::copy() {
SVEvent* any = new SVEvent;
any->command_id = command_id;
any->counter = counter;
any->parameter = new char[strlen(parameter) + 1];
strncpy(any->parameter, parameter, strlen(parameter));
any->parameter[strlen(parameter)] = '\0';
any->type = type;
any->x = x;
any->y = y;
any->x_size = x_size;
any->y_size = y_size;
any->window = window;
return any;
}
// This is the main loop which handles the ScrollView-logic from the server
// to the client. It basically loops through messages, parses them to events
// and distributes it to the waiting handlers.
// It is run from a different thread and synchronizes via SVSync.
void* ScrollView::MessageReceiver(void* a) {
int counter_event_id = 0; //ongoing counter
char* message = NULL;
// Wait until a new message appears in the input stream_.
do {
message = ScrollView::GetStream()->Receive();
} while (message == NULL);
// This is the main loop which iterates until the server is dead (strlen = -1).
// It basically parses for 3 different messagetypes and then distributes the
// events accordingly.
while (strlen(message) != -1) {
// The new event we create.
SVEvent* cur = new SVEvent;
// The ID of the corresponding window.
int window_id;
int ev_type;
if (kDebugMode) { std::cout << "(s->C)" << message << "\n"; }
int n;
// Fill the new SVEvent properly.
sscanf(message, "%d,%d,%d,%d,%d,%d,%d,%n", &window_id, &ev_type, &cur->x,
&cur->y, &cur->x_size, &cur->y_size, &cur->command_id, &n);
char* p = (message + n);
cur->window = svmap[window_id];
if (cur->window != NULL) {
cur->parameter = new char[strlen(p) + 1];
strncpy(cur->parameter, p, strlen(p) + 1);
if (strlen(p) > 0) { // remove the last \n
cur->parameter[strlen(p)] = '\0';
}
cur->type = static_cast<SVEventType>(ev_type);
cur->y = cur->window->TranslateYCoordinate(cur->y);
cur->counter = counter_event_id;
// Increase by 2 since we will also create an SVET_ANY event from cur, which
// will have a counter_id of cur + 1 (and thus gets processed after cur).
counter_event_id += 2;
// In case of an SVET_EXIT event, quit the whole application.
if (ev_type == SVET_EXIT) { ScrollView::Exit(); }
// Place two copies of it in the table for the window.
cur->window->SetEvent(cur);
// Check if any of the threads currently waiting want it.
std::pair<ScrollView*, SVEventType> awaiting_list(cur->window,
cur->type);
std::pair<ScrollView*, SVEventType> awaiting_list_any(cur->window,
SVET_ANY);
std::pair<ScrollView*, SVEventType> awaiting_list_any_window(NULL,
SVET_ANY);
mutex_waiting->Lock();
if (waiting_for_events.count(awaiting_list) > 0) {
waiting_for_events[awaiting_list].second = cur;
waiting_for_events[awaiting_list].first->Signal();
} else if (waiting_for_events.count(awaiting_list_any) > 0) {
waiting_for_events[awaiting_list_any].second = cur;
waiting_for_events[awaiting_list_any].first->Signal();
} else if (waiting_for_events.count(awaiting_list_any_window) > 0) {
waiting_for_events[awaiting_list_any_window].second = cur;
waiting_for_events[awaiting_list_any_window].first->Signal();
} else {
// No one wanted it, so delete it.
delete cur;
}
mutex_waiting->Unlock();
// Signal the corresponding semaphore twice (for both copies).
ScrollView* sv = svmap[window_id];
sv->Signal();
sv->Signal();
}
// Wait until a new message appears in the input stream_.
do {
message = ScrollView::GetStream()->Receive();
} while (message == NULL);
}
return 0;
}
// Table to implement the color index values in the old system.
int table_colors[ScrollView::GREEN_YELLOW+1][4]= {
{0, 0, 0, 0}, // NONE (transparent)
{0, 0, 0, 255}, // BLACK.
{255, 255, 255, 255}, // WHITE.
{255, 0, 0, 255}, // RED.
{255, 255, 0, 255}, // YELLOW.
{0, 255, 0, 255}, // GREEN.
{0, 255, 255, 255}, // CYAN.
{0, 0, 255, 255}, // BLUE.
{255, 0, 255, 255}, // MAGENTA.
{0, 128, 255, 255}, // AQUAMARINE.
{0, 0, 64, 255}, // DARK_SLATE_BLUE.
{128, 128, 255, 255}, // LIGHT_BLUE.
{64, 64, 255, 255}, // MEDIUM_BLUE.
{0, 0, 32, 255}, // MIDNIGHT_BLUE.
{0, 0, 128, 255}, // NAVY_BLUE.
{192, 192, 255, 255}, // SKY_BLUE.
{64, 64, 128, 255}, // SLATE_BLUE.
{32, 32, 64, 255}, // STEEL_BLUE.
{255, 128, 128, 255}, // CORAL.
{128, 64, 0, 255}, // BROWN.
{128, 128, 0, 255}, // SANDY_BROWN.
{192, 192, 0, 255}, // GOLD.
{192, 192, 128, 255}, // GOLDENROD.
{0, 64, 0, 255}, // DARK_GREEN.
{32, 64, 0, 255}, // DARK_OLIVE_GREEN.
{64, 128, 0, 255}, // FOREST_GREEN.
{128, 255, 0, 255}, // LIME_GREEN.
{192, 255, 192, 255}, // PALE_GREEN.
{192, 255, 0, 255}, // YELLOW_GREEN.
{192, 192, 192, 255}, // LIGHT_GREY.
{64, 64, 128, 255}, // DARK_SLATE_GREY.
{64, 64, 64, 255}, // DIM_GREY.
{128, 128, 128, 255}, // GREY.
{64, 192, 0, 255}, // KHAKI.
{255, 0, 192, 255}, // MAROON.
{255, 128, 0, 255}, // ORANGE.
{255, 128, 64, 255}, // ORCHID.
{255, 192, 192, 255}, // PINK.
{128, 0, 128, 255}, // PLUM.
{255, 0, 64, 255}, // INDIAN_RED.
{255, 64, 0, 255}, // ORANGE_RED.
{255, 0, 192, 255}, // VIOLET_RED.
{255, 192, 128, 255}, // SALMON.
{128, 128, 0, 255}, // TAN.
{0, 255, 255, 255}, // TURQUOISE.
{0, 128, 128, 255}, // DARK_TURQUOISE.
{192, 0, 255, 255}, // VIOLET.
{128, 128, 0, 255}, // WHEAT.
{128, 255, 0, 255} // GREEN_YELLOW
};
/*******************************************************************************
* Scrollview implementation.
*******************************************************************************/
SVNetwork* ScrollView::stream_ = NULL;
int ScrollView::nr_created_windows_ = 0;
// Calls Initialize with all arguments given.
ScrollView::ScrollView(const char* name, int x_pos, int y_pos, int x_size,
int y_size, int x_canvas_size, int y_canvas_size,
bool y_axis_reversed, const char* server_name) {
Initialize(name, x_pos, y_pos, x_size, y_size, x_canvas_size, y_canvas_size,
y_axis_reversed, server_name);}
// Calls Initialize with default argument for server_name_.
ScrollView::ScrollView(const char* name, int x_pos, int y_pos, int x_size,
int y_size, int x_canvas_size, int y_canvas_size,
bool y_axis_reversed) {
Initialize(name, x_pos, y_pos, x_size, y_size, x_canvas_size, y_canvas_size,
y_axis_reversed, "localhost");
}
// Calls Initialize with default argument for server_name_ & y_axis_reversed.
ScrollView::ScrollView(const char* name, int x_pos, int y_pos, int x_size,
int y_size, int x_canvas_size, int y_canvas_size) {
Initialize(name, x_pos, y_pos, x_size, y_size, x_canvas_size, y_canvas_size,
false, "localhost");
}
// Sets up a ScrollView window, depending on the constructor variables.
void ScrollView::Initialize(const char* name, int x_pos, int y_pos, int x_size,
int y_size, int x_canvas_size, int y_canvas_size,
bool y_axis_reversed, const char* server_name) {
// If this is the first ScrollView Window which gets created, there is no
// network connection yet and we have to set it up in a different thread.
if (stream_ == NULL) {
nr_created_windows_ = 0;
stream_ = new SVNetwork(server_name, kSvPort);
mutex_waiting = new SVMutex();
if (kDebugMode) {
std::cout << "(C->s) svmain = "
<< "luajava.bindClass('com.google.scrollview.ScrollView')\n";
}
SendRawMessage(
"svmain = luajava.bindClass('com.google.scrollview.ScrollView')\n");
SVSync::StartThread(MessageReceiver, NULL);
}
// Set up the variables on the clientside.
nr_created_windows_++;
event_handler_ = NULL;
y_axis_is_reversed_ = y_axis_reversed;
y_size_ = y_canvas_size;
window_name_ = name;
window_id_ = nr_created_windows_;
svmap[window_id_] = this;
for (int i = 0; i < SVET_COUNT; i++) {
event_table_[i] = NULL;
}
mutex_ = new SVMutex();
semaphore_ = new SVSemaphore();
// Set up an actual Window on the client side.
char message[kMaxMsgSize];
snprintf(message, sizeof(message),
"w%u = luajava.newInstance('com.google.scrollview.ui"
".SVWindow','%s',%u,%u,%u,%u,%u,%u,%u)\n",
window_id_, window_name_,
window_id_, x_pos,
TranslateYCoordinate(y_pos), x_size,
y_size_, x_canvas_size, y_canvas_size);
if (kDebugMode) {
std::cout << "(C->s)" << message;
}
SendRawMessage(message);
SVSync::StartThread(StartEventHandler, this);
}
// Sits and waits for events on this window.
void* ScrollView::StartEventHandler(void* a) {
ScrollView* sv = (ScrollView*) a;
SVEvent* new_event;
do {
stream_->Flush();
sv->semaphore_->Wait();
new_event = NULL;
int serial = INT_MAX;
int k = -1;
sv->mutex_->Lock();
// Check every table entry if he is is valid and not already processed.
for (int i = 0; i < SVET_COUNT; i++) {
if ((sv->event_table_[i] != NULL) &&
(sv->event_table_[i]->counter < serial)) {
new_event = sv->event_table_[i];
serial = sv->event_table_[i]->counter;
k = i;
}
}
// If we didnt find anything we had an old alarm and just sleep again.
if (new_event != NULL) {
sv->event_table_[k] = NULL;
sv->mutex_->Unlock();
if (sv->event_handler_ != NULL) { sv->event_handler_->Notify(new_event); }
if (new_event->type == SVET_DESTROY) { sv = NULL; }
delete new_event; // Delete the pointer after it has been processed.
} else { sv->mutex_->Unlock(); }
// The thread should run as long as its associated window is alive.
} while (sv != NULL);
return 0;
}
ScrollView::~ScrollView() {
// So the event handling thread can quit.
SendMsg("destroy()");
SVEvent* sve = AwaitEvent(SVET_DESTROY);
delete sve;
delete mutex_;
delete semaphore_;
svmap.erase(window_id_);
}
// Send a message to the server, attaching the window id.
void ScrollView::SendMsg(const char* format, ...) {
va_list args;
char message[kMaxMsgSize];
va_start(args, format); // variable list
vsnprintf(message, kMaxMsgSize, format, args);
va_end(args);
char form[kMaxMsgSize];
snprintf(form, kMaxMsgSize, "w%u:%s\n", window_id_, message);
if (kDebugMode) { std::cout << "(C->s)" << form; }
stream_->Send(form);
}
// Send a message to the server without a
// window id. Used for global events like exit().
void ScrollView::SendRawMessage(const char* msg) {
stream_->Send(msg);
}
// Add an Event Listener to this ScrollView Window
void ScrollView::AddEventHandler(SVEventHandler* listener) {
event_handler_ = listener;
}
void ScrollView::Signal() {
semaphore_->Signal();
}
void ScrollView::SetEvent(SVEvent* svevent) {
// Copy event
SVEvent* any = svevent->copy();
SVEvent* specific = svevent->copy();
any->counter = specific->counter + 1;
// Place both events into the queue.
mutex_->Lock();
// Delete the old objects..
if (event_table_[specific->type] != NULL) {
delete event_table_[specific->type]; }
if (event_table_[SVET_ANY] != NULL) {
delete event_table_[SVET_ANY]; }
// ...and put the new ones in the table.
event_table_[specific->type] = specific;
event_table_[SVET_ANY] = any;
mutex_->Unlock();
}
// Block until an event of the given type is received.
// Note: The calling function is responsible for deleting the returned
// SVEvent afterwards!
SVEvent* ScrollView::AwaitEvent(SVEventType type) {
// Initialize the waiting semaphore.
SVSemaphore* sem = new SVSemaphore();
std::pair<ScrollView*, SVEventType> ea(this, type);
mutex_waiting->Lock();
waiting_for_events[ea] = std::pair<SVSemaphore*, SVEvent*> (sem, NULL);
mutex_waiting->Unlock();
// Wait on it, but first flush.
stream_->Flush();
sem->Wait();
// Process the event we got woken up for (its in waiting_for_events pair).
mutex_waiting->Lock();
SVEvent* ret = waiting_for_events[ea].second;
waiting_for_events.erase(ea);
mutex_waiting->Unlock();
return ret;
}
// Block until any event on any window is received.
// No event is returned here!
SVEvent* ScrollView::AwaitEventAnyWindow() {
// Initialize the waiting semaphore.
SVSemaphore* sem = new SVSemaphore();
std::pair<ScrollView*, SVEventType> ea(NULL, SVET_ANY);
mutex_waiting->Lock();
waiting_for_events[ea] = std::pair<SVSemaphore*, SVEvent*> (sem, NULL);
mutex_waiting->Unlock();
// Wait on it.
stream_->Flush();
sem->Wait();
// Process the event we got woken up for (its in waiting_for_events pair).
mutex_waiting->Lock();
SVEvent* ret = waiting_for_events[ea].second;
waiting_for_events.erase(ea);
mutex_waiting->Unlock();
return ret;
}
/*******************************************************************************
* LUA "API" functions.
*******************************************************************************/
// Sets the position from which to draw to (x,y).
void ScrollView::SetCursor(int x, int y) {
current_position_x_ = x;
current_position_y_ = y;
}
// Draws from the current position to (x,y) and sets the new position to it.
void ScrollView::DrawTo(int x, int y) {
Line(current_position_x_, current_position_y_, x, y);
SetCursor(x, y);
}
// Set the visibility of the window.
void ScrollView::SetVisible(bool visible) {
if (visible) { SendMsg("setVisible(true)");
} else { SendMsg("setVisible(false)"); }
}
// Set the alwaysOnTop flag.
void ScrollView::AlwaysOnTop(bool b) {
if (b) { SendMsg("setAlwaysOnTop(true)");
} else { SendMsg("setAlwaysOnTop(false)"); }
}
// Adds a message entry to the message box.
void ScrollView::AddMessage(const char* format, ...) {
va_list args;
char message[kMaxMsgSize];
char form[kMaxMsgSize];
va_start(args, format); // variable list
vsnprintf(message, kMaxMsgSize, format, args);
va_end(args);
snprintf(form, kMaxMsgSize, "w%u:%s", window_id_, message);
char* esc = AddEscapeChars(form);
SendMsg("addMessage(\"%s\")", esc);
delete[] esc;
}
// Set a messagebox.
void ScrollView::AddMessageBox() {
SendMsg("addMessageBox()");
}
// Exit the client completely (and notify the server of it).
void ScrollView::Exit() {
SendRawMessage("svmain:exit()");
exit(0);
}
// Clear the canvas.
void ScrollView::Clear() {
SendMsg("clear()");
}
// Draw a line using the current pen color.
void ScrollView::Line(int x1, int y1, int x2, int y2) {
SendMsg("drawLine(%d,%d,%d,%d)",
x1, TranslateYCoordinate(y1), x2, TranslateYCoordinate(y2));
}
// Set the stroke width.
void ScrollView::Stroke(float width) {
SendMsg("setStrokeWidth(%f)", width);
}
// Draw a rectangle using the current pen color.
// The rectangle is filled with the current brush color.
void ScrollView::Rectangle(int x1, int y1, int x2, int y2) {
SendMsg("drawRectangle(%d,%d,%d,%d)",
x1, TranslateYCoordinate(y1), x2, TranslateYCoordinate(y2));
}
// Draw an ellipse using the current pen color.
// The ellipse is filled with the current brush color.
void ScrollView::Ellipse(int x1, int y1, int width, int height) {
SendMsg("drawEllipse(%d,%d,%u,%u)",
x1, TranslateYCoordinate(y1), width, height);
}
// Set the pen color to the given RGB values.
void ScrollView::Pen(int red, int green, int blue) {
SendMsg("pen(%d,%d,%d)", red, green, blue);
}
// Set the pen color to the given RGB values.
void ScrollView::Pen(int red, int green, int blue, int alpha) {
SendMsg("pen(%d,%d,%d,%d)", red, green, blue, alpha);
}
// Set the brush color to the given RGB values.
void ScrollView::Brush(int red, int green, int blue) {
SendMsg("brush(%d,%d,%d)", red, green, blue);
}
// Set the brush color to the given RGB values.
void ScrollView::Brush(int red, int green, int blue, int alpha) {
SendMsg("brush(%d,%d,%d,%d)", red, green, blue, alpha);
}
// Set the attributes for future Text(..) calls.
void ScrollView::TextAttributes(const char* font, int pixel_size,
bool bold, bool italic, bool underlined) {
const char* b;
const char* i;
const char* u;
if (bold) { b = "true";
} else { b = "false"; }
if (italic) { i = "true";
} else { i = "false"; }
if (underlined) { u = "true";
} else { u = "false"; }
SendMsg("textAttributes('%s',%u,%s,%s,%s)", font, pixel_size,
b, i, u);
}
// Draw text at the given coordinates.
void ScrollView::Text(int x, int y, const char* mystring) {
SendMsg("drawText(%d,%d,'%s')", x, TranslateYCoordinate(y), mystring);
}
// Open and draw an image given a name at (x,y).
void ScrollView::Image(const char* image, int x_pos, int y_pos) {
SendMsg("openImage('%s')", image);
SendMsg("drawImage('%s',%d,%d)",
image, x_pos, TranslateYCoordinate(y_pos));
}
// Add new checkboxmenuentry to menubar.
void ScrollView::MenuItem(const char* parent, const char* name,
int cmdEvent, bool flag) {
if (parent == NULL) { parent = ""; }
if (flag) { SendMsg("addMenuBarItem('%s','%s',%d,true)",
parent, name, cmdEvent);
} else { SendMsg("addMenuBarItem('%s','%s',%d,false)",
parent, name, cmdEvent); }
}
// Add new menuentry to menubar.
void ScrollView::MenuItem(const char* parent, const char* name, int cmdEvent) {
if (parent == NULL) { parent = ""; }
SendMsg("addMenuBarItem('%s','%s',%d)", parent, name, cmdEvent);
}
// Add new submenu to menubar.
void ScrollView::MenuItem(const char* parent, const char* name) {
if (parent == NULL) { parent = ""; }
SendMsg("addMenuBarItem('%s','%s')", parent, name);
}
// Add new submenu to popupmenu.
void ScrollView::PopupItem(const char* parent, const char* name) {
if (parent == NULL) { parent = ""; }
SendMsg("addPopupMenuItem('%s','%s')", parent, name);
}
// Add new submenuentry to popupmenu.
void ScrollView::PopupItem(const char* parent, const char* name,
int cmdEvent, const char* value, const char* desc) {
if (parent == NULL) { parent = ""; }
char* esc = AddEscapeChars(value);
char* esc2 = AddEscapeChars(desc);
SendMsg("addPopupMenuItem('%s','%s',%d,'%s','%s')", parent, name,
cmdEvent, esc, esc2);
delete[] esc;
delete[] esc2;
}
// Send an update message for a single window.
void ScrollView::UpdateWindow() {
SendMsg("update()");
}
// Note: this is an update to all windows
void ScrollView::Update() {
for (std::map<int, ScrollView*>::iterator iter = svmap.begin();
iter != svmap.end(); ++iter) {
iter->second->UpdateWindow();
}
}
// Set the pen color, using an enum value (e.g. ScrollView::ORANGE)
void ScrollView::Pen(Color color) {
Pen(table_colors[color][0], table_colors[color][1],
table_colors[color][2], table_colors[color][3]);
}
// Set the brush color, using an enum value (e.g. ScrollView::ORANGE)
void ScrollView::Brush(Color color) {
Brush(table_colors[color][0],
table_colors[color][1],
table_colors[color][2],
table_colors[color][3]);
}
// Shows a modal Input Dialog which can return any kind of String
char* ScrollView::ShowInputDialog(const char* msg) {
SendMsg("showInputDialog(\"%s\")", msg);
SVEvent* ev;
// wait till an input event (all others are thrown away)
ev = AwaitEvent(SVET_INPUT);
char* p = new char[strlen(ev->parameter) + 1];
strncpy(p, ev->parameter, strlen(ev->parameter));
p[strlen(ev->parameter)] = '\0';
delete ev;
return p;
}
// Shows a modal Yes/No Dialog which will return 'y' or 'n'
int ScrollView::ShowYesNoDialog(const char* msg) {
SendMsg("showYesNoDialog(\"%s\")", msg);
SVEvent* ev;
// Wait till an input event (all others are thrown away)
ev = AwaitEvent(SVET_INPUT);
int a = ev->parameter[0];
delete ev;
return a;
}
#ifdef HAVE_LIBLEPT
// Send an image of type PIX.
void ScrollView::Image(PIX* image, int x_pos, int y_pos) {
int width = image->w;
int height = image->h;
l_uint32 bpp = image->d;
// PIX* do not have a unique identifier/name associated, so name them "lept".
SendMsg("createImage('%u',%u,%u,%u)", "lept", width, height, bpp);
if (bpp == 32) {
Transfer32bppImage(image);
} else if (bpp == 8) {
TransferGrayImage(image);
} else if (bpp == 1) {
TransferBinaryImage(image);
}
// PIX* do not have a unique identifier/name associated, so name them "lept".
SendMsg("drawImage('%u',%d,%d)", "lept", x_pos, y_pos);
}
// Sends each pixel as hex value like html, e.g. #00FF00 for green.
void ScrollView::Transfer32bppImage(PIX* image) {
int ppL = pixGetWidth(image);
int h = pixGetHeight(image);
int wpl = pixGetWpl(image);
int transfer_size= ppL * 7 + 1;
char* pixel_data = new char[transfer_size];
for (int y = 0; y < h; ++y) {
l_uint32* data = pixGetData(image) + y*wpl;
for (int x = 0; x < ppL; ++x, ++data) {
snprintf(&pixel_data[x*7], 7, "#%.2x%.2x%.2x",
GET_DATA_BYTE(data, COLOR_RED),
GET_DATA_BYTE(data, COLOR_GREEN),
GET_DATA_BYTE(data, COLOR_BLUE));
}
pixel_data[transfer_size - 1] = '\0';
SendRawMessage(pixel_data);
}
delete[] pixel_data;
}
// TODO add RunLengthEncoding to this or something similar
// TODO testme
// Sends for each pixel either '1' or '0'.
void ScrollView::TransferGrayImage(PIX* image) {
char pixel_data[image->w * 2 + 1];
for (int y = 0; y < image->h; y++) {
l_uint32* data = pixGetData(image) + y * pixGetWpl(image);
for (int x = 0; x < image->w; x++) {
snprintf(&pixel_data[x*2], 2, "%.2x", (GET_DATA_BYTE(data, x)));
pixel_data[image->w * 2] = '\0';
SendRawMessage(pixel_data);
}
}
}
// TODO add RunLengthEncoding to this or something similar
// Sends for each pixel either '1' or '0'.
void ScrollView::TransferBinaryImage(PIX* image) {
char pixel_data[image->w + 1];
for (int y = 0; y < image->h; y++) {
l_uint32* data = pixGetData(image) + y * pixGetWpl(image);
for (int x = 0; x < image->w; x++) {
if (GET_DATA_BIT(data, x))
{ pixel_data[x] = '1'; }
else
{ pixel_data[x] = '0'; }
}
pixel_data[image->w] = '\0';
SendRawMessage(pixel_data);
}
}
#endif
// Escapes the ' character with a \, so it can be processed by LUA.
// Note: The caller will have to make sure he deletes the newly allocated item.
char* ScrollView::AddEscapeChars(const char* input) {
const char* nextptr = strchr(input, '\'');
const char* lastptr = input;
char* message = new char[kMaxMsgSize];
int pos = 0;
while (nextptr != NULL) {
strncpy(message+pos, lastptr, nextptr-lastptr);
pos += nextptr - lastptr;
message[pos] = '\\';
pos += 1;
lastptr = nextptr;
nextptr = strchr(nextptr+1, '\'');
}
strncpy(message+pos, lastptr, strlen(lastptr));
message[pos+strlen(lastptr)] = '\0';
return message;
}
// Inverse the Y axis if the coordinates are actually inversed.
int ScrollView::TranslateYCoordinate(int y) {
if (!y_axis_is_reversed_) { return y;
} else { return y_size_ - y; }
}

401
viewer/scrollview.h Normal file
View File

@ -0,0 +1,401 @@
///////////////////////////////////////////////////////////////////////
// File: scrollview.h
// Description: ScrollView
// Author: Joern Wanke
// Created: Thu Nov 29 2007
//
// (C) Copyright 2007, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
//
// ScrollView is designed as an UI which can be run remotely. This is the
// client code for it, the server part is written in java. The client consists
// mainly of 2 parts:
// The "core" ScrollView which sets up the remote connection,
// takes care of event handling etc.
// The other part of ScrollView consists of predefined API calls through LUA,
// which can basically be used to get a zoomable canvas in which it is possible
// to draw lines, text etc.
// Technically, thanks to LUA, its even possible to bypass the here defined LUA
// API calls at all and generate a java user interface from scratch (or
// basically generate any kind of java program, possibly even dangerous ones).
#ifndef THIRD_PARTY_TESSERACT_VIEWER_SCROLLVIEW_H__
#define THIRD_PARTY_TESSERACT_VIEWER_SCROLLVIEW_H__
#include <stdio.h>
class ScrollView;
class SVNetwork;
class SVMutex;
class SVSemaphore;
enum SVEventType {
SVET_DESTROY, // Window has been destroyed by user.
SVET_EXIT, // User has destroyed the last window by clicking on the 'X'.
SVET_CLICK, // Left button pressed.
SVET_SELECTION, // Left button selection.
SVET_INPUT, // There is some input (single key or a whole string).
SVET_MOUSE, // The mouse has moved with a button pressed.
SVET_MOTION, // The mouse has moved with no button pressed.
SVET_HOVER, // The mouse has stayed still for a second.
SVET_POPUP, // A command selected through a popup menu.
SVET_MENU, // A command selected through the menubar.
SVET_ANY, // Any of the above.
SVET_COUNT // Array sizing.
};
struct SVEvent {
~SVEvent() { delete [] parameter; }
SVEvent* copy();
SVEventType type; // What kind of event.
ScrollView* window; // Window event relates to.
int x; // Coords of click or selection.
int y;
int x_size; // Size of selection.
int y_size;
int command_id; // The ID of the possibly associated event (e.g. MENU)
char* parameter; // Any string that might have been passed as argument.
int counter; // Used to detect which kind of event to process next.
SVEvent() {
window = NULL;
parameter = NULL;
}
SVEvent(const SVEvent&);
SVEvent& operator=(const SVEvent&);
};
// The SVEventHandler class is used for Event handling: If you register your
// class as SVEventHandler to a ScrollView Window, the SVEventHandler will be
// called whenever an appropriate event occurs.
class SVEventHandler {
public:
// Gets called by the SV Window. Does nothing on default, overwrite this
// to implement the desired behaviour
virtual void Notify(const SVEvent* sve) { }
};
// The ScrollView class provides the expernal API to the scrollviewer process.
// The scrollviewer process manages windows and displays images, graphics and
// text while allowing the user to zoom and scroll the windows arbitrarily.
// Each ScrollView class instance represents one window, and stuff is drawn in
// the window through method calls on the class. The constructor is used to
// create the class instance (and the window).
class ScrollView {
public:
// Color enum for pens and brushes.
enum Color {
NONE,
BLACK,
WHITE,
RED,
YELLOW,
GREEN,
CYAN,
BLUE,
MAGENTA,
AQUAMARINE,
DARK_SLATE_BLUE,
LIGHT_BLUE,
MEDIUM_BLUE,
MIDNIGHT_BLUE,
NAVY_BLUE,
SKY_BLUE,
SLATE_BLUE,
STEEL_BLUE,
CORAL,
BROWN,
SANDY_BROWN,
GOLD,
GOLDENROD,
DARK_GREEN,
DARK_OLIVE_GREEN,
FOREST_GREEN,
LIME_GREEN,
PALE_GREEN,
YELLOW_GREEN,
LIGHT_GREY,
DARK_SLATE_GREY,
DIM_GREY,
GREY,
KHAKI,
MAROON,
ORANGE,
ORCHID,
PINK,
PLUM,
INDIAN_RED,
ORANGE_RED,
VIOLET_RED,
SALMON,
TAN,
TURQUOISE,
DARK_TURQUOISE,
VIOLET,
WHEAT,
GREEN_YELLOW // Make sure this one is last.
};
// Create a window. The pixel size of the window may be 0,0, in which case
// a default size is selected based on the size of your canvas.
// The canvas may not be 0,0 in size!
ScrollView(const char* name, int x_pos, int y_pos, int x_size, int y_size,
int x_canvas_size, int y_canvas_size);
// With a flag whether the x axis is reversed.
ScrollView(const char* name, int x_pos, int y_pos, int x_size, int y_size,
int x_canvas_size, int y_canvas_size, bool y_axis_reversed);
// Connect to a server other than localhost.
ScrollView(const char* name, int x_pos, int y_pos, int x_size, int y_size,
int x_canvas_size, int y_canvas_size, bool y_axis_reversed,
const char* server_name);
~ScrollView();
/*******************************************************************************
* Event handling
* To register as listener, the class has to derive from the SVEventHandler
* class, which consists of a notifyMe(SVEvent*) function that should be
* overwritten to process the event the way you want.
*******************************************************************************/
// Add an Event Listener to this ScrollView Window.
void AddEventHandler(SVEventHandler* listener);
// Block until an event of the given type is received.
SVEvent* AwaitEvent(SVEventType type);
// Block until any event on any window is received.
SVEvent* AwaitEventAnyWindow();
/*******************************************************************************
* Getters and Setters
*******************************************************************************/
// Returns the title of the window.
const char* GetName() { return window_name_; }
// Returns the unique ID of the window.
int GetId() { return window_id_; }
/*******************************************************************************
* API functions for LUA calls
* the implementations for these can be found in svapi.cc
* (keep in mind that the window is actually created through the ScrollView
* constructor, so this is not listed here)
*******************************************************************************/
#ifdef HAVE_LIBLEPT
// Draw a Pix on (x,y).
void Image(struct Pix* image, int x_pos, int y_pos);
#endif
// Flush buffers and update display.
static void Update();
// Exit the program.
static void Exit();
// Update the contents of a specific window.
void UpdateWindow();
// Erase all content from the window, but do not destroy it.
void Clear();
// Set pen color with an enum.
void Pen(Color color);
// Set pen color to RGB (0-255).
void Pen(int red, int green, int blue);
// Set pen color to RGBA (0-255).
void Pen(int red, int green, int blue, int alpha);
// Set brush color with an enum.
void Brush(Color color);
// Set brush color to RGB (0-255).
void Brush(int red, int green, int blue);
// Set brush color to RGBA (0-255).
void Brush(int red, int green, int blue, int alpha);
// Set attributes for future text, like font name (e.g.
// "Times New Roman"), font size etc..
// Note: The underlined flag is currently not supported
void TextAttributes(const char* font, int pixel_size,
bool bold, bool italic, bool underlined);
// Draw line from (x1,y1) to (x2,y2) with the current pencolor.
void Line(int x1, int y1, int x2, int y2);
// Set the stroke width of the pen.
void Stroke(float width);
// Draw a rectangle given upper left corner and lower right corner.
// The current pencolor is used as outline, the brushcolor to fill the shape.
void Rectangle(int x1, int y1, int x2, int y2);
// Draw an ellipse centered on (x,y).
// The current pencolor is used as outline, the brushcolor to fill the shape.
void Ellipse(int x, int y, int width, int height);
// Draw text with the current pencolor
void Text(int x, int y, const char* mystring);
// Draw an image from a local filename. This should be faster than createImage.
// WARNING: This only works on a local machine. This also only works image
// types supported by java (like bmp,jpeg,gif,png) since the image is opened by
// the server.
void Image(const char* image, int x_pos, int y_pos);
// Set the current position to draw from (x,y). In conjunction with...
void SetCursor(int x, int y);
// ...this function, which draws a line from the current to (x,y) and then
// sets the new position to the new (x,y), this can be used to easily draw
// polygons using vertices
void DrawTo(int x, int y);
// Set the SVWindow visible/invisible.
void SetVisible(bool visible);
// Set the SVWindow always on top or not always on top.
void AlwaysOnTop(bool b);
// Shows a modal dialog with "msg" as question and returns 'y' or 'n'.
int ShowYesNoDialog(const char* msg);
// Shows a modal dialog with "msg" as question and returns a char* string.
// Constraint: As return, only words (e.g. no whitespaces etc.) are allowed.
char* ShowInputDialog(const char* msg);
// Adds a messagebox to the SVWindow. This way, it can show the messages...
void AddMessageBox();
// ...which can be added by this command.
// This is intended as an "debug" output window.
void AddMessage(const char* format, ...);
// Custom messages (manipulating java code directly) can be send through this.
// Send a message to the server and attach the Id of the corresponding window.
// Note: This should only be called if you are know what you are doing, since
// you are fiddling with the Java objects on the server directly. Calling
// this just for fun will likely break your application!
// It is public so you can actually take use of the LUA functionalities, but
// be careful!
void SendMsg(const char* msg, ...);
// Custom messages (manipulating java code directly) can be send through this.
// Send a message to the server without adding the
// window id. Used for global events like Exit().
// Note: This should only be called if you are know what you are doing, since
// you are fiddling with the Java objects on the server directly. Calling
// this just for fun will likely break your application!
// It is public so you can actually take use of the LUA functionalities, but
// be careful!
static void SendRawMessage(const char* msg);
/*******************************************************************************
* Add new menu entries to parent. If parent is "", the entry gets added to the
* main menubar (toplevel).
*******************************************************************************/
// This adds a new submenu to the menubar.
void MenuItem(const char* parent, const char* name);
// This adds a new (normal) menu entry with an associated eventID, which should
// be unique among menubar eventIDs.
void MenuItem(const char* parent, const char* name, int cmdEvent);
// This adds a new checkbox entry, which might initally be flagged.
void MenuItem(const char* parent, const char* name,
int cmdEvent, bool flagged);
// This adds a new popup submenu to the popup menu. If parent is "", the entry
// gets added at "toplevel" popupmenu.
void PopupItem(const char* parent, const char* name);
// This adds a new popup entry with the associated eventID, which should be
// unique among popup eventIDs.
// If value and desc are given, on a click the server will ask you to modify
// the value and return the new value.
void PopupItem(const char* parent, const char* name,
int cmdEvent, const char* value, const char* desc);
// Returns the correct Y coordinate for a window, depending on whether it might
// have to be flipped (by ySize).
int TranslateYCoordinate(int y);
private:
#ifdef HAVE_LIBLEPT
// Transfers a binary Image.
void TransferBinaryImage(struct Pix* image);
// Transfers a gray scale Image.
void TransferGrayImage(struct Pix* image);
// Transfers a 32-Bit Image.
void Transfer32bppImage(struct Pix* image);
#endif
// Sets up ScrollView, depending on the variables from the constructor.
void Initialize(const char* name, int x_pos, int y_pos, int x_size,
int y_size, int x_canvas_size, int y_canvas_size,
bool y_axis_reversed, const char* server_name);
// Start the message receiving thread.
static void* MessageReceiver(void* a);
// Place an event into the event_table (synchronized).
void SetEvent(SVEvent* svevent);
// Wake up the semaphore.
void Signal();
// Returns the unique, shared network stream.
static SVNetwork* GetStream() { return stream_; }
// Starts a new event handler. Called whenever a new window is created.
static void* StartEventHandler(void* sv);
// Escapes the ' character with a \, so it can be processed by LUA.
char* AddEscapeChars(const char* input);
// The event handler for this window.
SVEventHandler* event_handler_;
// The name of the window.
const char* window_name_;
// The id of the window.
int window_id_;
// The points last set by setCursor(x,y) or then updated by drawTo(x,y).
int current_position_x_, current_position_y_;
// Whether the axis is reversed.
bool y_axis_is_reversed_;
// If the y axis is reversed, flip all y values by ySize.
int y_size_;
// # of created windows (used to assign an id to each ScrollView* for svmap).
static int nr_created_windows_;
// The stream through which the c++ client is connected to the server.
static SVNetwork* stream_;
// Table of all the currently queued events.
SVEvent* event_table_[SVET_COUNT];
// Mutex to access the event_table_ in a synchronized fashion.
SVMutex* mutex_;
// Semaphore to the thread belonging to this window.
SVSemaphore* semaphore_;
};
#endif // THIRD_PARTY_TESSERACT_VIEWER_SCROLLVIEW_H__

84
viewer/showim.cpp
View File

@ -1,84 +0,0 @@
/**********************************************************************
* File: showimg.c (Formerly showim.c)
* Description: Interface to sbdaemon for displaying images.
* Author: Ray Smith
* Created: Mon Jun 11 16:20:34 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "mfcpch.h"
#include "grphshm.h"
#include "showim.h"
void (*show_func) (IMAGE *, INT32, INT32, INT32, INT32, WINDOW, INT32,
INT32) = def_show_sub_image;
/**********************************************************************
* show_sub_image
*
* Send the given image to the daemon and insert it in the display list.
**********************************************************************/
DLLSYM void def_show_sub_image( //show this image
IMAGE *source, //image to show
INT32 xstart, //start coords
INT32 ystart,
INT32 xext, //extent to show
INT32 yext,
WINDOW win, //window to draw in
INT32 xpos, //position to show at
INT32 ypos //y position
) {
EIGHTOP *newop; //message structure
INT32 y; //y coord
INT32 linelength; //bytes per line
IMAGE dummyimage; //used for copying to
IMAGEOP *sendline; //transmitted line
INT32 structsize; //size of structure
INT32 destbpp; //destination bits per pixel
destbpp = source->get_bpp (); //send all images unchanged
newop = (EIGHTOP *) getshm (sizeof (EIGHTOP));
if (newop != NULL) {
//send the fd
newop->header.fd = win->get_fd ();
newop->type = SHOWIMAGE; //send the operator
newop->param.p[0].i = xext; //send parameters
newop->param.p[1].i = yext;
newop->param.p[2].i = destbpp;
newop->param.p[3].i = xpos;
newop->param.p[4].i = ypos;
//bytes required
linelength = COMPUTE_IMAGE_XDIM (xext, destbpp);
linelength++; //round up to next
linelength &= ~1; //multiple of 2
//size of structure
structsize = (INT32) (sizeof (IMAGEOP) + linelength - 2);
for (y = yext - 1; y >= 0; --y) {
//get space
sendline = (IMAGEOP *) getshm (structsize);
if (sendline != NULL) {
sendline->header.fd = win->get_fd ();
sendline->type = SHOWLINE;
sendline->size = structsize;
dummyimage.capture (sendline->line, xext, 1, (INT8) destbpp);
//ready for copy
//copy to shm
copy_sub_image (source, xstart, ystart + y, xext, 1, &dummyimage, 0, 0, FALSE);
}
}
}
}

41
viewer/showim.h
View File

@ -1,41 +0,0 @@
/**********************************************************************
* File: showimg.c (Formerly showim.c)
* Description: Interface to sbdaemon for displaying images.
* Author: Ray Smith
* Created: Mon Jun 11 16:20:34 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef SHOWIM_H
#define SHOWIM_H
#include "grphics.h"
#include "img.h"
#define show_sub_image(im,xstart,ystart,xext,yext,win,xpos,ypos) (*show_func)(im,xstart,ystart,xext,yext,win,xpos,ypos)
extern void (*show_func) (IMAGE *, INT32, INT32, INT32, INT32, WINDOW, INT32,
INT32);
DLLSYM void def_show_sub_image( //show this image
IMAGE *source, //image to show
INT32 xstart, //start coords
INT32 ystart,
INT32 xext, //extent to show
INT32 yext,
WINDOW win, //window to draw in
INT32 xpos, //position to show at
INT32 ypos //y position
);
#endif

134
viewer/svmnode.cpp Normal file
View File

@ -0,0 +1,134 @@
///////////////////////////////////////////////////////////////////////
// File: svmnode.cpp
// description_: ScrollView Menu Node
// Author: Joern Wanke
// Created: Thu Nov 29 2007
//
// (C) Copyright 2007, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
//
// A SVMenuNode is an entity which contains the mapping from a menu entry on
// the server side to the corresponding associated commands on the client.
// It is designed to be a tree structure with a root node, which can then be
// used to generate the appropriate messages to the server to display the
// menu structure there.
// A SVMenuNode can both be used in the context_ of popup menus as well as
// menu bars.
#include "svmnode.h"
#include <iostream>
#include "scrollview.h"
// Create the empty root menu node. with just a caption. All other nodes should
// be added to this or one of the submenus.
SVMenuNode::SVMenuNode() {
cmd_event_ = -1;
text_ = NULL;
child_ = NULL;
next_ = NULL;
parent_ = NULL;
toggle_value_ = false;
is_check_box_entry_ = false;
value_ = NULL;
description_ = NULL;
}
SVMenuNode::~SVMenuNode() {
delete[] text_;
// delete[] description_;
}
// Create a new sub menu node with just a caption. This is used to create
// nodes which act as parent nodes to other nodes (e.g. submenus).
SVMenuNode* SVMenuNode::AddChild(const char* txt) {
SVMenuNode* s = new SVMenuNode(-1, txt, false, false, NULL, NULL);
this->AddChild(s);
return s;
}
// Create a "normal" menu node which is associated with a command event.
void SVMenuNode::AddChild(const char* txt, int command_event) {
this->AddChild(new SVMenuNode(command_event, txt, false, false, NULL, NULL));
}
// Create a menu node with an associated value (which might be changed
// through the gui).
void SVMenuNode::AddChild(const char* txt, int command_event,
const char* val) {
this->AddChild(new SVMenuNode(command_event, txt, false, false, val, NULL));
}
// Create a menu node with an associated value and description_.
void SVMenuNode::AddChild(const char* txt, int command_event, const char* val,
const char* desc) {
this->AddChild(new SVMenuNode(command_event, txt, false, false, val, desc));
}
// Create a flag menu node.
void SVMenuNode::AddChild(const char* txt, int command_event, int tv) {
this->AddChild(new SVMenuNode(command_event, txt, tv, true, NULL, NULL));
}
// Convenience function called from the different constructors to initialize
// the different values of the menu node.
SVMenuNode::SVMenuNode(int command_event, const char* txt,
int tv, bool check_box_entry, const char* val,
const char* desc) {
cmd_event_ = command_event;
text_ = new char[strlen(txt) + 1];
strncpy(text_, txt, strlen(txt));
text_[strlen(txt)] = '\0';
value_ = val;
description_ = desc;
child_ = NULL;
next_ = NULL;
parent_ = NULL;
toggle_value_ = tv;
is_check_box_entry_ = check_box_entry;
}
// Add a child node to this menu node.
void SVMenuNode::AddChild(SVMenuNode* svmn) {
svmn->parent_ = this;
// No children yet.
if (child_ == NULL) {
child_ = svmn;
} else {
SVMenuNode* cur = child_;
while (cur->next_ != NULL) { cur = cur->next_; }
cur->next_ = svmn;
}
}
// Build a menu structure for the server and send the necessary messages.
// Should be called on the root node. If menu_bar is true, a menu_bar menu
// is built (e.g. on top of the window), if it is false a popup menu is
// built which gets shown by right clicking on the window.
// Deletes itself afterwards.
void SVMenuNode::BuildMenu(ScrollView* sv, bool menu_bar) {
if ((parent_ != NULL) && (menu_bar)) {
if (is_check_box_entry_) {
sv->MenuItem(parent_->text_, text_, cmd_event_, toggle_value_);
} else { sv->MenuItem(parent_->text_, text_, cmd_event_); }
} else if ((parent_ != NULL) && (!menu_bar)) {
if (description_ != NULL) { sv->PopupItem(parent_->text_, text_,
cmd_event_, value_, description_);
} else { sv->PopupItem(parent_->text_, text_); }
}
if (child_ != NULL) { child_->BuildMenu(sv, menu_bar); delete child_; }
if (next_ != NULL) { next_->BuildMenu(sv, menu_bar); delete next_; }
}

94
viewer/svmnode.h Normal file
View File

@ -0,0 +1,94 @@
///////////////////////////////////////////////////////////////////////
// File: svmnode.h
// description_: ScrollView Menu Node
// Author: Joern Wanke
// Created: Thu Nov 29 2007
//
// (C) Copyright 2007, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
//
// A SVMenuNode is an entity which contains the mapping from a menu entry on
// the server side to the corresponding associated commands on the client.
// It is designed to be a tree structure with a root node, which can then be
// used to generate the appropriate messages to the server to display the
// menu structure there.
// A SVMenuNode can both be used in the context_ of popup menus as well as
// menu bars.
#ifndef THIRD_PARTY_TESSERACT_VIEWER_SVMNODE_H__
#define THIRD_PARTY_TESSERACT_VIEWER_SVMNODE_H__
class ScrollView;
class SVMenuNode {
public:
// Creating the (empty) root menu node.
SVMenuNode();
// Destructor for every node.
~SVMenuNode();
// Create a new sub menu node with just a caption. This is used to create
// nodes which act as parent nodes to other nodes (e.g. submenus).
SVMenuNode* AddChild(const char* txt);
// Create a "normal" menu node which is associated with a command event.
void AddChild(const char* txt, int command_event);
// Create a flag menu node.
void AddChild(const char* txt, int command_event, int tv);
// Create a menu node with an associated value (which might be changed
// through the gui).
void AddChild(const char* txt, int command_event, const char* val);
// Create a menu node with an associated value and description_.
void AddChild(const char* txt, int command_event,
const char* val, const char* desc);
// Build a menu structure for the server and send the necessary messages.
// Should be called on the root node. If menu_bar is true, a menu_bar menu
// is built (e.g. on top of the window), if it is false a popup menu is
// built which gets shown by right clicking on the window.
void BuildMenu(ScrollView *sv, bool menu_bar = true);
private:
// Constructor holding the actual node data.
SVMenuNode(int command_event, const char* txt, int tv,
bool check_box_entry, const char* val, const char* desc);
// Adds a new menu node to the current node.
void AddChild(SVMenuNode* svmn);
// The parent node of this node.
SVMenuNode* parent_;
// The first child of this node.
SVMenuNode* child_;
// The next "sibling" of this node (e.g. same parent).
SVMenuNode* next_;
// Whether this menu node actually is a flag.
bool is_check_box_entry_;
// The command event associated with a specific menu node. Should be unique.
int cmd_event_;
// The caption associated with a specific menu node.
char* text_;
// The value of the flag (if this menu node is a flag).
bool toggle_value_;
// The value of the menu node. (optional)
const char* value_;
// A description_ of the value. (optional)
const char* description_;
};
#endif // THIRD_PARTY_TESSERACT_VIEWER_SVMNODE_H__

220
viewer/svpaint.cpp Normal file
View File

@ -0,0 +1,220 @@
// Copyright 2007 Google Inc. All Rights Reserved.
//
// Author: Joern Wanke
//
// Simple drawing program to illustrate ScrollView capabilities.
//
// Functionality:
// - The menubar is used to select from different sample styles of input.
// - With the RMB it is possible to change the RGB values in different
// popup menus.
// - A LMB click either draws point-to-point, point or text.
// - A LMB dragging either draws a line, a rectangle or ellipse.
#include "scrollview.h"
#include "svmnode.h"
#include <stdlib.h>
#include <iostream>
// The current color values we use, initially white (== ScrollView::WHITE).
int rgb[3] = { 255, 255, 255 };
class SVPaint : public SVEventHandler {
public:
SVPaint(const char* server_name);
// This is the main event handling function that we need to overwrite, defined
// in SVEventHandler.
void Notify(const SVEvent* sv_event);
private:
// The Handler take care of the SVET_POPUP, SVET_MENU, SVET_CLICK and
// SVET_SELECTION events.
void PopupHandler(const SVEvent* sv_event);
void MenuBarHandler(const SVEvent* sv_event);
void ClickHandler(const SVEvent* sv_event);
void SelectionHandler(const SVEvent* sv_event);
// Convenience functions to build little menus.
SVMenuNode* BuildPopupMenu();
SVMenuNode* BuildMenuBar();
// Our window.
ScrollView* window_;
// The mode we are in when an SVET_CLICK or an SVET_SELECTION event occurs.
int click_mode_;
int drag_mode_;
// In the point-to-point drawing mode, we need to set a start-point the first
// time we call it (e.g. call SetCursor).
bool has_start_point_;
};
// Build a sample popup menu.
SVMenuNode* SVPaint::BuildPopupMenu() {
SVMenuNode* root = new SVMenuNode(); // Empty root node
// Initial color is white, so we all values to 255.
root->AddChild("R", // Shown caption.
1, // assoc. command_id.
"255", // initial value.
"Red Color Value?"); // Shown description.
root->AddChild("G", 2, "255", "Green Color Value?");
root->AddChild("B", 3, "255", "Blue Color Value?");
return root;
}
// Build a sample menu bar.
SVMenuNode* SVPaint::BuildMenuBar() {
SVMenuNode* root = new SVMenuNode(); // Empty root node
// Create some submenus and add them to the root.
SVMenuNode* click = root->AddChild("Clicking");
SVMenuNode* drag = root->AddChild("Dragging");
// Put some nodes into the submenus.
click->AddChild("Point to Point Drawing", // Caption.
1); // command_id.
click->AddChild("Point Drawing", 2);
click->AddChild("Text Drawing", 3);
drag->AddChild("Line Drawing", 4);
drag->AddChild("Rectangle Drawing", 5);
drag->AddChild("Ellipse Drawing", 6);
return root;
}
// Takes care of the SVET_POPUP events.
// In our case, SVET_POPUP is used to set RGB values.
void SVPaint::PopupHandler(const SVEvent* sv_event) {
// Since we only have the RGB values as popup items,
// we take a shortcut to not bloat up code:
rgb[sv_event->command_id - 1] = atoi(sv_event->parameter);
window_->Pen(rgb[0], rgb[1], rgb[2]);
}
// Takes care of the SVET_MENU events.
// In our case, we change either the click_mode_ (commands 1-3)
// or the drag_mode_ (commands 4-6).
void SVPaint::MenuBarHandler(const SVEvent* sv_event) {
if ((sv_event->command_id > 0) && (sv_event->command_id < 4)) {
click_mode_ = sv_event->command_id;
has_start_point_ = false;
} else { drag_mode_ = sv_event->command_id; }
}
// Takes care of the SVET_CLICK events.
// Depending on the click_mode_ we are in, either do Point-to-Point drawing,
// point drawing, or draw text.
void SVPaint::ClickHandler(const SVEvent* sv_event) {
switch (click_mode_) {
case 1: //Point to Point
if (has_start_point_) { window_->DrawTo(sv_event->x, sv_event->y);
} else {
has_start_point_ = true;
window_->SetCursor(sv_event->x, sv_event->y);
}
break;
case 2: //Point Drawing..simulated by drawing a 1 pixel line.
window_->Line(sv_event->x, sv_event->y, sv_event->x, sv_event->y);
break;
case 3: //Text
// We show a modal input dialog on our window, then draw the input and
// finally delete the input pointer.
char* p = window_->ShowInputDialog("Text:");
window_->Text(sv_event->x, sv_event->y, p);
delete p;
break;
}
}
// Takes care of the SVET_SELECTION events.
// Depending on the drag_mode_ we are in, either draw a line, a rectangle or
// an ellipse.
void SVPaint::SelectionHandler(const SVEvent* sv_event) {
switch (drag_mode_) {
//FIXME inversed x_size, y_size
case 4: //Line
window_->Line(sv_event->x, sv_event->y,
sv_event->x - sv_event->x_size,
sv_event->y - sv_event->y_size);
break;
case 5: //Rectangle
window_->Rectangle(sv_event->x, sv_event->y,
sv_event->x - sv_event->x_size,
sv_event->y - sv_event->y_size);
break;
case 6: //Ellipse
window_->Ellipse(sv_event->x - sv_event->x_size,
sv_event->y - sv_event->y_size,
sv_event->x_size, sv_event->y_size);
break;
}
}
// The event handling function from ScrollView which we have to overwrite.
// We handle CLICK, SELECTION, MENU and POPUP and throw away all other events.
void SVPaint::Notify(const SVEvent* sv_event) {
if (sv_event->type == SVET_CLICK) { ClickHandler(sv_event); }
else if (sv_event->type == SVET_SELECTION) { SelectionHandler(sv_event); }
else if (sv_event->type == SVET_MENU) { MenuBarHandler(sv_event); }
else if (sv_event->type == SVET_POPUP) { PopupHandler(sv_event); }
else {} //throw other events away
}
// Builds a new window, initializes the variables and event handler and builds
// the menu.
SVPaint::SVPaint(const char *server_name) {
window_ = new ScrollView("ScrollView Paint Example", // window caption
0, 0, // x,y window position
500, 500, // window size
500, 500, // canvas size
false, // whether the Y axis is inversed.
// this is included due to legacy
// reasons for tesseract and enables
// us to have (0,0) as the LOWER left
// of the coordinate system.
server_name); // the server address.
// Set the start modes to point-to-point and line drawing.
click_mode_ = 1;
drag_mode_ = 4;
has_start_point_ = false;
// Bild our menus and add them to the window. The flag illustrates whether
// this is a menu bar.
SVMenuNode* popup_menu = BuildPopupMenu();
popup_menu->BuildMenu(window_,false);
SVMenuNode* bar_menu = BuildMenuBar();
bar_menu->BuildMenu(window_,true);
// Set the initial color values to White (could also be done by
// passing (rgb[0], rgb[1], rgb[2]).
window_->Pen(ScrollView::WHITE);
window_->Brush(ScrollView::WHITE);
// Adds the event handler to the window. This actually ensures that Notify
// gets called when events occur.
window_->AddEventHandler(this);
// Set the window visible (calling this is important to actually render
// everything. Without this call, the window would also be drawn, but the
// menu bars would be missing.
window_->SetVisible(true);
// Rest this thread until its window is destroyed.
// Note that a special eventhandling thread was created when constructing
// the window. Due to this, the application will not deadlock here.
window_->AwaitEvent(SVET_DESTROY);
// We now have 3 Threads running:
// (1) The MessageReceiver thread which fetches messages and distributes them
// (2) The EventHandler thread which handles all events for window_
// (3) The main thread which waits on window_ for a DESTROY event (blocked)
}
// If a parameter is given, we try to connect to the given server.
// This enables us to test the remote capabilites of ScrollView.
int main(int argc, char** argv) {
const char* server_name;
if (argc > 1) { server_name = argv[1]; } else { server_name = "localhost"; }
SVPaint svp(server_name);
}

323
viewer/svutil.cpp Normal file
View File

@ -0,0 +1,323 @@
///////////////////////////////////////////////////////////////////////
// File: svutil.cpp
// Description: ScrollView Utilities
// Author: Joern Wanke
// Created: Thu Nov 29 2007
//
// (C) Copyright 2007, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
//
// SVUtil contains the SVSync and SVNetwork classes, which are used for
// thread/process creation & synchronization and network connection.
#include "svutil.h"
#ifdef WIN32
#include <windows.h>
#include <winsock.h>
#else
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <netdb.h>
#include <sys/socket.h>
#endif
#include <iostream>
#include <string>
const int kBufferSize = 65536;
const int kMaxMsgSize = 4096;
// Signals a thread to exit.
void SVSync::ExitThread() {
#ifdef WIN32
//ExitThread(0);
#else
pthread_exit(0);
#endif
}
// Starts a new process.
void SVSync::StartProcess(const char* executable, const char* args) {
#ifdef WIN32
std::string proc;
proc.append(executable);
proc.append(" ");
proc.append(args);
std::cout << "Starting " << proc << std::endl;
CreateProcess(NULL, (LPWSTR) proc.c_str(), NULL,
NULL, FALSE, 0, NULL, NULL, NULL, NULL);
#else
int pid = fork();
if (pid != 0) { // The father process returns
} else {
char* mutable_args = strdup(args);
int argc = 1;
for (int i = 0; mutable_args[i]; ++i) {
if (mutable_args[i] == ' ') {
++argc;
}
}
char** argv = new char*[argc + 2];
argv[0] = strdup(executable);
argv[1] = mutable_args;
argc = 2;
bool inquote = false;
for (int i = 0; mutable_args[i]; ++i) {
if (!inquote && mutable_args[i] == ' ') {
mutable_args[i] = '\0';
argv[argc++] = mutable_args + i + 1;
} else if (mutable_args[i] == '"') {
inquote = !inquote;
mutable_args[i] = ' ';
}
}
argv[argc] = NULL;
execvp(executable, argv);
}
#endif
}
SVSemaphore::SVSemaphore() {
#ifdef WIN32
semaphore_ = CreateSemaphore(0, 0, 10, 0);
#else
sem_init(&semaphore_, 0, 0);
#endif
}
void SVSemaphore::Signal() {
#ifdef WIN32
ReleaseSemaphore(semaphore_, 1, NULL);
#else
sem_post(&semaphore_);
#endif
}
void SVSemaphore::Wait() {
#ifdef WIN32
WaitForSingleObject(semaphore_, INFINITE);
#else
sem_wait(&semaphore_);
#endif
}
SVMutex::SVMutex() {
#ifdef WIN32
mutex_ = CreateMutex(0, FALSE, 0);
#else
pthread_mutex_init(&mutex_, NULL);
#endif
}
void SVMutex::Lock() {
#ifdef WIN32
WaitForSingleObject(mutex_, INFINITE);
#else
pthread_mutex_lock(&mutex_);
#endif
}
void SVMutex::Unlock() {
#ifdef WIN32
ReleaseMutex(mutex_);
#else
pthread_mutex_unlock(&mutex_);
#endif
}
// Create new thread.
int SVSync::StartThread(void *(*func)(void*), void* arg) {
#ifdef WIN32
LPTHREAD_START_ROUTINE f = (LPTHREAD_START_ROUTINE) func;
DWORD threadid;
HANDLE newthread = CreateThread(
NULL, // default security attributes
0, // use default stack size
f, // thread function
arg, // argument to thread function
0, // use default creation flags
&threadid); // returns the thread identifier
return threadid;
#else
pthread_t helper;
pthread_create(&helper, NULL, func, arg);
return helper;
#endif
}
// Place a message in the message buffer (and flush it).
void SVNetwork::Send(const char* msg) {
mutex_send_->Lock();
msg_buffer_out_.append(msg);
mutex_send_->Unlock();
}
// Send the whole buffer.
void SVNetwork::Flush() {
mutex_send_->Lock();
while (msg_buffer_out_.size() > 0) {
int i = send(stream_, msg_buffer_out_.c_str(), msg_buffer_out_.length(), 0);
msg_buffer_out_.erase(0, i);
}
mutex_send_->Unlock();
}
// Receive a message from the server.
// This will always return one line of char* (denoted by \n).
char* SVNetwork::Receive() {
char* result = NULL;
#ifdef WIN32
if (has_content) { result = strtok (NULL, "\n"); }
#else
if (buffer_ptr_ != NULL) { result = strtok_r(NULL, "\n", &buffer_ptr_); }
#endif
// This means there is something left in the buffer and we return it.
if (result != NULL) { return result;
// Otherwise, we read from the stream_.
} else {
buffer_ptr_ = NULL;
has_content = false;
// The timeout length is not really important since we are looping anyway
// until a new message is delivered.
struct timeval tv;
tv.tv_sec = 10;
tv.tv_usec = 0;
// Set the flags to return when the stream_ is ready to be read.
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(stream_, &readfds);
int i = select(stream_+1, &readfds, NULL, NULL, &tv);
// The stream_ died.
if (i == 0) { return NULL; }
// Read the message buffer.
i = recv(stream_, msg_buffer_in_, kMaxMsgSize, 0);
// Server quit (0) or error (-1).
if (i <= 0) { return NULL; }
msg_buffer_in_[i] = '\0';
has_content = true;
#ifdef WIN32
return strtok(msg_buffer_in_,"\n");
#else
// Setup a new string tokenizer.
return strtok_r(msg_buffer_in_, "\n", &buffer_ptr_);
#endif
}
}
// Close the connection to the server.
void SVNetwork::Close() {
#ifdef WIN32
closesocket(stream_);
#else
close(stream_);
#endif
}
// Set up a connection to hostname on port.
SVNetwork::SVNetwork(const char* hostname, int port) {
mutex_send_ = new SVMutex();
struct sockaddr_in address;
struct hostent *name;
msg_buffer_in_ = new char[kMaxMsgSize + 1];
msg_buffer_in_[0] = '\0';
has_content = false;
buffer_ptr_ = NULL;
// Get the host data depending on the OS.
#ifdef WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD(1, 1), &wsaData);
name = gethostbyname(hostname);
#else
struct hostent hp;
int herr;
char buffer[kBufferSize];
gethostbyname_r(hostname, &hp, buffer, kBufferSize, &name, &herr);
#endif
// Fill in the appropriate variables to be able to connect to the server.
address.sin_family = name->h_addrtype;
memcpy((char *) &address.sin_addr.s_addr,
name->h_addr_list[0], name->h_length);
address.sin_port = htons(port);
stream_ = socket(AF_INET, SOCK_STREAM, 0);
// If server is not there, we will start a new server as local child process.
if (connect(stream_, (struct sockaddr *) &address, sizeof(address)) < 0) {
const char* scrollview_path = getenv("SCROLLVIEW_PATH");
if (scrollview_path == NULL) {
#ifdef SCROLLVIEW_PATH
#define _STR(a) #a
#define _XSTR(a) _STR(a)
scrollview_path = _XSTR(SCROLLVIEW_PATH);
#undef _XSTR
#undef _STR
#else
scrollview_path = ".";
#endif
}
#ifdef WIN32
const char* prog = "java";
const char* cmd_template =
#else
const char* prog = "sh";
const char* cmd_template = "-c \"java "
#endif
"-Djava.library.path=%s -cp %s/luajava-1.1.jar:%s/ScrollView.jar:"
"%s/piccolo-1.2.jar:%s/piccolox-1.2.jar"
" com.google.scrollview.ScrollView"
#ifdef WIN32
;
#else
" >/dev/null 2>&1\"";
#endif
int cmdlen = strlen(cmd_template) + 5*strlen(scrollview_path) + 1;
char* cmd = new char[cmdlen];
snprintf(cmd, cmdlen, cmd_template, scrollview_path, scrollview_path,
scrollview_path, scrollview_path, scrollview_path);
SVSync::StartProcess(prog, cmd);
delete [] cmd;
// Wait for server to show up.
// Note: There is no exception handling in case the server never turns up.
while (connect(stream_, (struct sockaddr *) &address,
sizeof(address)) < 0) {
std::cout << "ScrollView: Waiting for server...\n";
#ifdef WIN32
Sleep(1000);
#else
sleep(1);
#endif
}
}
}
SVNetwork::~SVNetwork() {
delete[] msg_buffer_in_;
delete mutex_send_;
}

124
viewer/svutil.h Normal file
View File

@ -0,0 +1,124 @@
///////////////////////////////////////////////////////////////////////
// File: svutil.h
// Description: ScrollView Utilities
// Author: Joern Wanke
// Created: Thu Nov 29 2007
//
// (C) Copyright 2007, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
//
// SVUtil contains the SVSync, SVSemaphore, SVMutex and SVNetwork
// classes, which are used for thread/process creation & synchronization
// and network connection.
#ifndef THIRD_PARTY_TESSERACT_VIEWER_SVUTIL_H__
#define THIRD_PARTY_TESSERACT_VIEWER_SVUTIL_H__
#ifdef WIN32
#include <windows.h>
#else
#include <pthread.h>
#include <semaphore.h>
#endif
#include <string>
// The SVSync class provides functionality for Thread & Process Creation
class SVSync {
public:
// Create new thread.
static int StartThread(void *(*func)(void*), void* arg);
// Signals a thread to exit.
static void ExitThread();
// Starts a new process.
static void StartProcess(const char* executable, const char* args);
};
// A semaphore class which encapsulates the main signalling
// and wait abilities of semaphores for windows and unix.
class SVSemaphore {
public:
// Sets up a semaphore.
SVSemaphore();
// Signal a semaphore.
void Signal();
// Wait on a semaphore.
void Wait();
private:
#ifdef WIN32
HANDLE semaphore_;
#else
sem_t semaphore_;
#endif
};
// A mutex which encapsulates the main locking and unlocking
// abilites of mutexes for windows and unix.
class SVMutex {
public:
// Sets up a new mutex.
SVMutex();
// Locks on a mutex.
void Lock();
// Unlocks on a mutex.
void Unlock();
private:
#ifdef WIN32
HANDLE mutex_;
#else
pthread_mutex_t mutex_;
#endif
};
// The SVNetwork class takes care of the remote connection for ScrollView
// This means setting up and maintaining a remote connection, sending and
// receiving messages and closing the connection.
// It is designed to work on both Linux and Windows.
class SVNetwork {
public:
// Set up a connection to hostname on port.
SVNetwork(const char* hostname, int port);
// Destructor.
~SVNetwork();
// Put a message in the messagebuffer to the server and try to send it.
void Send(const char* msg);
// Receive a message from the server.
// This will always return one line of char* (denoted by \n).
char* Receive();
// Close the connection to the server.
void Close();
// Flush the buffer.
void Flush();
private:
// The mutex for access to Send() and Flush().
SVMutex* mutex_send_;
// The actual stream_ to the server.
int stream_;
// Stores the last received message-chunk from the server.
char* msg_buffer_in_;
// Stores the messages which are supposed to go out.
std::string msg_buffer_out_;
bool has_content; // Win32 (strtok)
// Where we are at in our msg_buffer_in_
char* buffer_ptr_; // Unix (strtok_r)
};
#endif // THIRD_PARTY_TESSERACT_VIEWER_SVUTIL_H__