void status_bar() {
unsigned int i, y;
XSetWindowAttributes setattr;
setattr.override_redirect = True;
unsigned long vmask = CWOverrideRedirect;
y = (topbar == 0) ? 0+ug_bar : desktops[barmon].h+bdw-ug_bar;
sb_width = ug_bar;
for(i=0;i<DESKTOPS;++i) {
sb_bar[i].sb_win = XCreateSimpleWindow(dis, root, desktops[barmon].x+sb_width, y,
sb_bar[i].width-2,sb_height,2,theme[3].barcolor,theme[0].barcolor);
XSelectInput(dis, sb_bar[i].sb_win, ButtonPressMask|EnterWindowMask|LeaveWindowMask);
XChangeWindowAttributes(dis, sb_bar[i].sb_win, vmask, &setattr);
XMapWindow(dis, sb_bar[i].sb_win);
sb_width += sb_bar[i].width;
}
sb_area = XCreateSimpleWindow(dis, root, desktops[barmon].x+sb_desks+ug_bar, y,
desktops[barmon].w-lessbar-(sb_desks+2)-2*ug_bar,sb_height,2,theme[3].barcolor,theme[1].barcolor);
XSelectInput(dis, sb_area, ButtonPressMask|ExposureMask|EnterWindowMask|LeaveWindowMask);
XChangeWindowAttributes(dis, sb_area, vmask, &setattr);
XMapWindow(dis, sb_area);
XWindowAttributes attr;
XGetWindowAttributes(dis, sb_area, &attr);
total_w = attr.width;
area_sb = XCreatePixmap(dis, root, total_w, sb_height, DefaultDepth(dis, screen));
XFillRectangle(dis, area_sb, theme[0].gc, 0, 0, total_w, sb_height+4);
status_text("");
update_bar();
}
void update_bar() {
unsigned int i;
for(i=0;i<DESKTOPS;++i) {
if(i != current_desktop) {
if(desktops[i].head != NULL) {
draw_desk(sb_bar[i].sb_win, 2, 3, (sb_bar[i].width-sb_bar[i].labelwidth)/2, sb_bar[i].label, strlen(sb_bar[i].label));
if(showopen < 1 && desktops[i].numorder > 1) {
draw_numopen(i, 3);
}
} else {
draw_desk(sb_bar[i].sb_win, 1, 2, (sb_bar[i].width-sb_bar[i].labelwidth)/2, sb_bar[i].label, strlen(sb_bar[i].label));
}
if(i == previous_desktop)
XFillRectangle(dis, sb_bar[i].sb_win, theme[3].gc, 0, 0, 2, 2);
} else {
draw_desk(sb_bar[i].sb_win, 0, 1, (sb_bar[i].width-sb_bar[i].labelwidth)/2, sb_bar[i].label, strlen(sb_bar[i].label));
if(showopen == 0 && (desktops[i].mode == 1 || desktops[i].mode == 4) && desktops[i].numorder > 1) {
draw_numopen(i, 1);
}
}
}
if(focus != NULL) getwindowname(focus->win, 0);
else status_text("");
}
void getwindowname(Window win, unsigned int stext) {
char *win_name;
if(XFetchName(dis, win, &win_name) != 0) strncpy(winname, win_name, 100);
else winname[0] = '\0';
if(win_name) XFree(win_name);
if(stext == 0) status_text(winname);
}
static void add_filter_callback(GtkWidget *widget, GtkWidget *nothing)
{
if(GLOBALS->num_proc_filters == PROC_FILTER_MAX)
{
status_text("Max number of process filters installed already.\n");
return;
}
fileselbox("Select Filter Process",&GLOBALS->fcurr_ptranslate_c_1,GTK_SIGNAL_FUNC(add_filter_callback_2), GTK_SIGNAL_FUNC(NULL),"*", 0);
}
static void add_filter_callback(GtkWidget *widget, GtkWidget *nothing)
{
(void)widget;
(void)nothing;
if(GLOBALS->num_file_filters == FILE_FILTER_MAX)
{
status_text("Max number of file filters installed already.\n");
return;
}
fileselbox("Select Filter File",&GLOBALS->fcurr_translate_c_2,GTK_SIGNAL_FUNC(add_filter_callback_2), GTK_SIGNAL_FUNC(NULL),NULL, 0);
}
static void add_filter_callback_2(GtkWidget *widget, GtkWidget *nothing)
{
(void)widget;
(void)nothing;
int i;
GtkCList *cl;
if(!GLOBALS->filesel_ok) { return; }
if(*GLOBALS->fileselbox_text)
{
for(i=0;i<GLOBALS->num_file_filters;i++)
{
if(GLOBALS->filesel_filter[i])
{
if(!strcmp(GLOBALS->filesel_filter[i], *GLOBALS->fileselbox_text))
{
status_text("Filter already imported.\n");
if(GLOBALS->is_active_translate_c_5) gdk_window_raise(GLOBALS->window_translate_c_11->window);
return;
}
}
}
}
GLOBALS->num_file_filters++;
load_file_filter(GLOBALS->num_file_filters, *GLOBALS->fileselbox_text);
if(GLOBALS->xl_file_filter[GLOBALS->num_file_filters] && (*GLOBALS->fileselbox_text /* scan-build */))
{
if(GLOBALS->filesel_filter[GLOBALS->num_file_filters]) free_2(GLOBALS->filesel_filter[GLOBALS->num_file_filters]);
GLOBALS->filesel_filter[GLOBALS->num_file_filters] = malloc_2(strlen(*GLOBALS->fileselbox_text) + 1);
strcpy(GLOBALS->filesel_filter[GLOBALS->num_file_filters], *GLOBALS->fileselbox_text);
cl=GTK_CLIST(GLOBALS->clist_translate_c_4);
gtk_clist_freeze(cl);
gtk_clist_append(cl,(gchar **)&(GLOBALS->filesel_filter[GLOBALS->num_file_filters]));
gtk_clist_set_column_width(cl,0,gtk_clist_optimal_column_width(cl,0));
gtk_clist_thaw(cl);
}
else
{
GLOBALS->num_file_filters--;
}
if(GLOBALS->is_active_translate_c_5) gdk_window_raise(GLOBALS->window_translate_c_11->window);
}
static void load_file_filter(int which, char *name)
{
FILE *f = fopen(name, "rb");
if(!f)
{
status_text("Could not open filter file!\n");
return;
}
remove_file_filter(which, 0); /* should never happen from GUI, but possible from save files or other weirdness */
while(!feof(f))
{
char *s = fgetmalloc(f);
if(s)
{
char *lhs = s;
while(*lhs && isspace((int)(unsigned char)*lhs)) lhs++;
if(lhs)
{
char *rhs = lhs;
if(*lhs != '#') /* ignore comments */
{
while(*rhs && !isspace((int)(unsigned char)*rhs)) rhs++;
if(*rhs)
{
char *xlt = rhs+1;
*rhs = 0;
while(*xlt && isspace((int)(unsigned char)*xlt)) xlt++;
if(*xlt)
{
GLOBALS->xl_file_filter[which] = xl_insert(lhs, GLOBALS->xl_file_filter[which], xlt);
}
}
}
}
free_2(s);
}
}
fclose(f);
}
static gint button_release_event(GtkWidget *widget, GdkEventButton *event)
{
int which;
if(event->button==1)
{
if(dnd_state==0) cachedwhich=-1;
gdk_pointer_ungrab(event->time);
DEBUG(printf("Button 1 released\n"));
}
/********************* button 3 *********************/
if((event->button==3)&&(signalpixmap))
{
cachedwhich=-1;
gdk_pointer_ungrab(event->time);
DEBUG(printf("Button 3 released\n"));
if(dnd_state==1)
{
if(cachedtrace)
{
cachedtrace->flags|=TR_HIGHLIGHT;
}
which=(int)(event->y);
which=(which/fontheight)-1;
if( ((which<0) && (topmost_trace==traces.first) && PrependBuffer()) || (PasteBuffer()) ) /* short circuit on special which<0 case */
{
status_text("Drop completed.\n");
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
wavearea_configure_event(wavearea, NULL);
}
dnd_state=0;
}
}
/********************* button 3 *********************/
return(TRUE);
}
static void load_enums_filter(int which, char *name)
{
int argc;
char **spl = zSplitTclList(name, &argc);
int i;
if((!spl)||(!argc)||(argc&1))
{
status_text("Malformed enums list!\n");
return;
}
remove_file_filter(which, 0); /* should never happen from GUI, but possible from save files or other weirdness */
for(i=0;i<argc;i+=2)
{
char *lhs = spl[i];
char *xlt = spl[i+1];
GLOBALS->xl_file_filter[which] = xl_insert(lhs, GLOBALS->xl_file_filter[which], xlt);
}
free_2(spl);
}
/*
* complain about certain ops conflict with dnd...
*/
void dnd_error(void)
{
status_text("Can't perform that operation when waveform drag and drop is in progress!\n");
}
static gint button_press_event(GtkWidget *widget, GdkEventButton *event)
{
int num_traces_displayable;
int which;
int trwhich, trtarget;
GtkAdjustment *wadj;
Trptr t;
if((traces.total)&&(signalpixmap))
{
gdk_pointer_grab(widget->window, FALSE,
GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON3_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK, NULL, NULL, event->time);
num_traces_displayable=widget->allocation.height/(fontheight);
num_traces_displayable--; /* for the time trace that is always there */
which=(int)(event->y);
which=(which/fontheight)-1;
if((which>=traces.total)||(which>=num_traces_displayable)||(which<0))
{
if(dnd_state==0)cachedwhich=-1;
goto check_button_3; /* off in no man's land, but check 3rd anyways.. */
}
cachedwhich=which; /* cache for later fill in */
wadj=GTK_ADJUSTMENT(wave_vslider);
trtarget=((int)wadj->value)+which;
t=traces.first;
trwhich=0;
while(t)
{
if((trwhich<trtarget)&&(t->next))
{
trwhich++;
t=t->next;
}
else
{
break;
}
}
cachedtrace=t;
if((dnd_state==0)&&(event->button==1))
if(t)
{
int yval;
GtkAdjustment *hadj;
gint xsrc;
if((shift_click_trace)&&(event->state&GDK_SHIFT_MASK))
{
Trptr t2;
unsigned int f;
t2=shift_click_trace;
while(t2)
{
if(t2==t)
{
t2=shift_click_trace;
f=t2->flags&TR_HIGHLIGHT;
while(t2)
{
t2->flags = (t2->flags & (~TR_HIGHLIGHT)) | f;
if(t2==t) break;
t2=t2->prev;
}
goto resync_signalarea;
}
t2=t2->prev;
}
t2=shift_click_trace;
while(t2)
{
if(t2==t)
{
t2=shift_click_trace;
f=t2->flags&TR_HIGHLIGHT;
while(t2)
{
t2->flags = (t2->flags & (~TR_HIGHLIGHT)) | f;
if(t2==t) break;
t2=t2->next;
}
goto resync_signalarea;
}
t2=t2->next;
}
goto normal_button1_press; /* couldn't find original so make this original... */
resync_signalarea:
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
DEBUG(printf("Shift-Click in signalarea!\n"));
return(TRUE);
}
else
{
normal_button1_press:
hadj=GTK_ADJUSTMENT(signal_hslider);
xsrc=(gint)hadj->value;
shift_click_trace=t;
t->flags ^= TR_HIGHLIGHT;
cachedhiflag = t->flags & TR_HIGHLIGHT;
DEBUG(printf("Button pressed in signalarea at x: %d, y: %d row: %d\n",
(int)event->x, (int)event->y, which));
yval=RenderSig(t, which, 1);
gdk_draw_pixmap(signalarea->window, signalarea->style->fg_gc[GTK_WIDGET_STATE(signalarea)],
signalpixmap,
xsrc, yval,
0, yval,
signalarea->allocation.width, fontheight-1);
}
}
check_button_3:
if(event->button==3)
{
if(dnd_state==0)
{
if(CutBuffer())
{
char buf[32];
sprintf(buf,"Dragging %d trace%s.\n",traces.buffercount,traces.buffercount!=1?"s":"");
status_text(buf);
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
wavearea_configure_event(wavearea, NULL);
dnd_state=1;
}
}
}
}
return(TRUE);
}
static void load_proc_filter(int which, char *name)
{
FILE *stream;
char *cmd;
char exec_name[1025];
char abs_path [1025];
char* arg, end;
int result;
exec_name[0] = 0;
abs_path[0] = 0;
/* if name has arguments grab only the first word (the name of the executable)*/
sscanf(name, "%s ", exec_name);
arg = name + strlen(exec_name);
/* remove leading spaces from argument */
while (isspace((int)(unsigned char)arg[0])) {
arg++;
}
/* remove trailing spaces from argument */
if (strlen(arg) > 0) {
end = strlen(arg) - 1;
while (arg[(int)end] == ' ') {
arg[(int)end] = 0;
end--;
}
}
/* turn the exec_name into an absolute path */
#if !defined __MINGW32__ && !defined _MSC_VER
cmd = (char *)malloc_2(strlen(exec_name)+6+1);
sprintf(cmd, "which %s", exec_name);
stream = popen(cmd, "r");
result = fscanf(stream, "%s", abs_path);
if((strlen(abs_path) == 0)||(!result))
{
status_text("Could not find filter process!\n");
return;
}
pclose(stream);
free_2(cmd);
#else
strcpy(abs_path, exec_name);
#endif
/* remove_proc_filter(which, 0); ... should never happen from GUI, but perhaps possible from save files or other weirdness */
if(!GLOBALS->ttrans_filter[which])
{
GLOBALS->proc_filter[which] = pipeio_create(abs_path, arg);
}
}
void ParticleFilterViewer::paintEvent(QPaintEvent* )
{
QPen pen(Qt::black, 2, Qt::SolidLine);
QPainter painter(this);
double width = this->visibleRegion().boundingRect().width();
double height = this->visibleRegion().boundingRect().height();
double top = 20;
double bottom = height - 20;
double left = 20;
double right = width - 20;
double w_scalar = (bottom - top) / map->width;
double h_scalar = (right - left) / map->height;
//draw map
painter.setPen(pen);
for(int i=0;i<map->parts.size();i++) {
painter.drawLine(left + map->parts[i].v0.x() * w_scalar , top + map->parts[i].v0.y() * h_scalar,
left + map->parts[i].v1.x() * w_scalar, top + map->parts[i].v1.y() * h_scalar );
}
//actual
//robot
int robot_w = 15 * w_scalar;
int robot_h = 10 * h_scalar;
pen = QPen(Qt::black, 2, Qt::SolidLine);
painter.setPen(pen);
painter.save();
painter.translate(left + robot->x * w_scalar, top + robot->y * h_scalar);
painter.rotate(robot->dir * 180 / PI);
painter.drawRect(-robot_w/2, -robot_h/2, robot_w, robot_h);
painter.restore();
//particles
painter.setPen( QPen( Qt::NoPen ) );
for(int i=0;i<particleFilter->pnum;i++) {
painter.setBrush(QBrush(QColor(0,0,0)));
painter.drawEllipse(left + particleFilter->p[i].x * w_scalar, top + particleFilter->p[i].y * h_scalar, 5, 5);
painter.setPen(QPen(QColor(255,0,0)));
//painter.drawLine(left + particleFilter->p[i].x * w_scalar, top + particleFilter->p[i].y * h_scalar, \
left + particleFilter->p[i].p.x() * w_scalar, top + particleFilter->p[i].p.y() * h_scalar);
//painter.drawLine(left + particleFilter->p[i].x * w_scalar, top + particleFilter->p[i].y * h_scalar, \
left + particleFilter->p[i].p1.x() * w_scalar, top + particleFilter->p[i].p1.y() * h_scalar);
}
//best estimate
Particle p = particleFilter->getWieghtedAverage();
painter.setBrush(QBrush(QColor(0,0,255)));
painter.drawEllipse(left + p.x * w_scalar, top + p.y * h_scalar, 5, 5);
painter.setPen(QPen(QColor(0,0,0)));
double error = d_abs(p.x - robot->x) + d_abs(p.y - robot->y) + d_abs(p.dir - robot->dir);
QString status = QString::number(error);
QStaticText status_text(status);
painter.drawStaticText(0,0, status_text);
if(particleFilter->isLocalized()) {
state_error.push_back(error);
double mean = 0;
int total = state_error.size();
for(int i=0;i<total;i++) {
mean += state_error[i];
}
mean /= total;
QString status = "State error:" + QString::number(mean);
QStaticText status_text(status);
painter.drawStaticText(0,20, status_text);
}
}
int main(int argc, const char *argv[])
{
try
{
CmdArgParser parser(argc, argv);
parser.setHeader("Archive Export version " ARCH_VERSION_TXT ", "
EPICS_VERSION_STRING
", built " __DATE__ ", " __TIME__ "\n\n");
parser.setArgumentsInfo("<index file> {channel}");
CmdArgFlag be_verbose (parser, "verbose", "Verbose mode");
CmdArgString pattern (parser, "match", "<reg. exp.>",
"Channel name pattern");
CmdArgFlag do_list (parser, "list", "List all channels");
CmdArgFlag do_info (parser, "info", "Time-range info on channels");
CmdArgString start_time (parser, "start", "<time>",
"Format: \"mm/dd/yyyy[ hh:mm:ss[.nano-secs]]\"");
CmdArgString end_time (parser, "end", "<time>", "(exclusive)");
CmdArgFlag status_text(parser, "text",
"Include text column for status/severity (default)");
CmdArgFlag no_status_text(parser, "no_text",
"Exclude text column for status/severity");
CmdArgString output (parser,
"output", "<file>", "Output to file");
CmdArgDouble plotbin (parser,
"plotbin", "<seconds>",
"Bin the raw data for plotting");
CmdArgDouble average (parser,
"average", "<seconds>", "average values");
CmdArgDouble linear (parser,
"linear", "<seconds>",
"Interpolate values linearly");
CmdArgString format_txt (parser,
"format", "<decimal|engineering|exponential>",
"Use specific format for numbers");
CmdArgInt prec (parser,
"precision", "<int>", "Precision of numbers");
CmdArgFlag GNUPlot (parser,
"gnuplot", "Generate GNUPlot command file");
CmdArgFlag image (parser,
"Gnuplot", "Generate GNUPlot output for Image");
CmdArgFlag raw_time (parser, "raw_time",
"Include columns for EPICS time stamp");
CmdArgFlag millisecs (parser, "millisecs",
"Truncate time to millisecs in spreadsheet dump.");
// defaults
prec.set(-1);
if (! parser.parse())
return -1;
if (parser.getArguments().size() < 1)
{
parser.usage();
return -1;
}
precision = prec;
if (!strncmp(format_txt.get().c_str(), "d", 1))
format = RawValue::DECIMAL;
else if (!strncmp(format_txt.get().c_str(), "en", 2))
format = RawValue::ENGINEERING;
else if (!strncmp(format_txt.get().c_str(), "ex", 2))
format = RawValue::EXPONENTIAL;
else if (format_txt.get().length() > 0)
{
fprintf(stderr, "Unknown format string '%s'\n", format_txt.get().c_str());
return -1;
}
verbose = be_verbose;
only_millisecs = millisecs;
// Start/end time
AutoPtr<epicsTime> start, end;
stdString txt;
if (start_time.get().length() > 0)
{
start = new epicsTime;
if (!string2epicsTime(start_time.get(), *start))
{
fprintf(stderr, "Parse error for start time '%s'\n",
start_time.get().c_str());
start = 0;
parser.usage();
return -1;
}
if (verbose)
printf("Using start time %s\n", epicsTimeTxt(*start, txt));
}
if (end_time.get().length() > 0)
{
end = new epicsTime();
if (!string2epicsTime(end_time.get(), *end))
{
fprintf(stderr, "Parse error for end time '%s'\n",
end_time.get().c_str());
end = 0;
parser.usage();
return -1;
}
if (verbose)
printf("Using end time %s\n", epicsTimeTxt(*end, txt));
}
if (start && end && *start > *end)
{ // Could simply swap start and end, but assume the user is
// confused and should rethink the request.
fprintf(stderr, "start time is greater than end time.\n");
return -1;
}
// Index name
stdString index_name = parser.getArgument(0);
// Channel names
stdVector<stdString> names;
if (parser.getArguments().size() > 1)
{
if (! pattern.get().empty())
{
fputs("Pattern from '-m' switch is ignored\n"
"since a list of channels was also provided.\n", stderr);
}
// first argument was directory file name, skip that:
for (size_t i=1; i<parser.getArguments().size(); ++i)
names.push_back(parser.getArgument(i));
}
if ((GNUPlot || image) && output.get().length() == 0)
{
fprintf(stderr, "The -gnuplot/Gnuplot options require "
"an -output file\n");
return -1;
}
// How?
ReaderFactory::How how = ReaderFactory::Raw;
double delta = 0.0;
if (double(plotbin) > 0.0)
{
how = ReaderFactory::Plotbin;
delta = double(plotbin);
}
else if (double(average) > 0.0)
{
how = ReaderFactory::Average;
delta = double(average);
}
else if (double(linear) > 0.0)
{
how = ReaderFactory::Linear;
delta = double(linear);
}
// Open index
AutoIndex index;
index.open(index_name.c_str());
if (verbose)
printf("Opened index '%s'\n", index_name.c_str());
if (do_info && names.size()<=0 && pattern.get().length()<=0)
do_list.set(); // otherwise it'd be a NOP
if (names.size() <= 0 &&
(do_list || pattern.get().length() > 0))
get_names_for_pattern(index, names, pattern);
if (do_info)
list_channels(index, names, true);
else if (do_list)
list_channels(index, names, false);
else if (names.size() > 0)
{
if (GNUPlot || image)
dump_gnuplot(index, names, start, end,
how, delta, output, image);
else
dump_spreadsheet(index, names, start, end,
raw_time, !no_status_text, how, delta,
output);
}
index.close();
}
catch (GenericException &e)
{
fprintf(stderr, "Error:\n%s\n", e.what());
return -1;
}
return 0;
}
static void logbox_reload_single(GtkWidget *window, GtkWidget *text, char *default_text)
{
FILE *handle;
struct wave_logfile_lines_t *wlog_head=NULL, *wlog_curr=NULL;
int wlog_size = 0;
handle = fopen(default_text, "rb");
if(!handle)
{
char *buf = malloc_2(strlen(default_text)+128);
sprintf(buf, "Could not open logfile '%s'\n", default_text);
status_text(buf);
free_2(buf);
return;
}
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
{
GtkTextIter st_iter, en_iter;
gtk_text_buffer_get_start_iter(GTK_TEXT_VIEW (text)->buffer, &st_iter);
gtk_text_buffer_get_end_iter(GTK_TEXT_VIEW (text)->buffer, &en_iter);
gtk_text_buffer_delete(GTK_TEXT_VIEW (text)->buffer, &st_iter, &en_iter);
gtk_text_buffer_get_start_iter (GTK_TEXT_VIEW (text)->buffer, &GLOBALS->iter_logfile_c_2);
}
#else
{
guint len = gtk_text_get_length(GTK_TEXT(text));
gtk_text_set_point(GTK_TEXT(text), 0);
gtk_text_freeze(GTK_TEXT(text));
gtk_text_forward_delete (GTK_TEXT(text), len);
}
#endif
log_text_bold(text, NULL, "Click-select");
log_text(text, NULL, " on numbers to jump to that time value in the wave viewer.\n");
log_text(text, NULL, " \n");
while(!feof(handle))
{
char *pnt = fgetmalloc(handle);
if(pnt)
{
struct wave_logfile_lines_t *w = calloc_2(1, sizeof(struct wave_logfile_lines_t));
wlog_size += (GLOBALS->fgetmalloc_len+1);
w->text = pnt;
if(!wlog_curr) { wlog_head = wlog_curr = w; } else { wlog_curr->next = w; wlog_curr = w; }
}
}
if(wlog_curr)
{
struct wave_logfile_lines_t *w = wlog_head;
struct wave_logfile_lines_t *wt;
char *pnt = malloc_2(wlog_size + 1);
char *pnt2 = pnt;
while(w)
{
int len = strlen(w->text);
memcpy(pnt2, w->text, len);
pnt2 += len;
*pnt2 = '\n';
pnt2++;
free_2(w->text);
wt = w;
w = w->next;
free_2(wt);
}
/* wlog_head = */ wlog_curr = NULL; /* scan-build */
*pnt2 = 0;
log_text(text, GLOBALS->font_logfile_c_1, pnt);
free_2(pnt);
}
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
#else
gtk_text_thaw(GTK_TEXT(text));
#endif
fclose(handle);
}
void logbox(char *title, int width, char *default_text)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *hbox, *button1;
GtkWidget *label, *separator;
GtkWidget *ctext;
GtkWidget *text;
struct logfile_instance_t *log_c;
FILE *handle;
struct wave_logfile_lines_t *wlog_head=NULL, *wlog_curr=NULL;
int wlog_size = 0;
handle = fopen(default_text, "rb");
if(!handle)
{
char *buf = malloc_2(strlen(default_text)+128);
sprintf(buf, "Could not open logfile '%s'\n", default_text);
status_text(buf);
free_2(buf);
return;
}
/* fix problem where ungrab doesn't occur if button pressed + simultaneous accelerator key occurs */
if(GLOBALS->in_button_press_wavewindow_c_1) { gdk_pointer_ungrab(GDK_CURRENT_TIME); }
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
/* nothing */
#else
if(!GLOBALS->font_logfile_c_1)
{
if(GLOBALS->fontname_logfile)
{
GLOBALS->font_logfile_c_1=gdk_font_load(GLOBALS->fontname_logfile);
}
if(!GLOBALS->font_logfile_c_1)
{
#ifndef __CYGWIN__
GLOBALS->font_logfile_c_1=gdk_font_load(GLOBALS->use_big_fonts
? "-*-courier-*-r-*-*-18-*-*-*-*-*-*-*"
: "-*-courier-*-r-*-*-10-*-*-*-*-*-*-*");
#else
GLOBALS->font_logfile_c_1=gdk_font_load(GLOBALS->use_big_fonts
? "-misc-fixed-*-*-*-*-18-*-*-*-*-*-*-*"
: "-misc-fixed-*-*-*-*-10-*-*-*-*-*-*-*");
#endif
}
}
#endif
/* create a new nonmodal window */
window = gtk_window_new(GLOBALS->disable_window_manager ? GTK_WINDOW_POPUP : GTK_WINDOW_TOPLEVEL);
if(GLOBALS->use_big_fonts || GLOBALS->fontname_logfile)
{
gtk_widget_set_usize( GTK_WIDGET (window), width*1.8, 600);
}
else
{
gtk_widget_set_usize( GTK_WIDGET (window), width, 400);
}
gtk_window_set_title(GTK_WINDOW (window), title);
gtk_signal_connect(GTK_OBJECT (window), "delete_event", (GtkSignalFunc) destroy_callback, window);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
label=gtk_label_new(default_text);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
ctext=create_log_text(&text);
gtk_box_pack_start (GTK_BOX (vbox), ctext, TRUE, TRUE, 0);
gtk_widget_show (ctext);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
hbox = gtk_hbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button1 = gtk_button_new_with_label ("Close Logfile");
gtk_widget_set_usize(button1, 100, -1);
gtk_signal_connect(GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC(ok_callback), window);
gtk_widget_show (button1);
gtk_container_add (GTK_CONTAINER (hbox), button1);
GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button1), "realize", (GtkSignalFunc) gtk_widget_grab_default, GTK_OBJECT (button1));
gtk_widget_show(window);
log_text_bold(text, NULL, "Click-select");
log_text(text, NULL, " on numbers to jump to that time value in the wave viewer.\n");
log_text(text, NULL, " \n");
while(!feof(handle))
{
char *pnt = fgetmalloc(handle);
if(pnt)
{
struct wave_logfile_lines_t *w = calloc_2(1, sizeof(struct wave_logfile_lines_t));
wlog_size += (GLOBALS->fgetmalloc_len+1);
w->text = pnt;
if(!wlog_curr) { wlog_head = wlog_curr = w; } else { wlog_curr->next = w; wlog_curr = w; }
}
}
if(wlog_curr)
{
struct wave_logfile_lines_t *w = wlog_head;
struct wave_logfile_lines_t *wt;
char *pnt = malloc_2(wlog_size + 1);
char *pnt2 = pnt;
while(w)
{
int len = strlen(w->text);
memcpy(pnt2, w->text, len);
pnt2 += len;
*pnt2 = '\n';
pnt2++;
free_2(w->text);
wt = w;
w = w->next;
free_2(wt);
}
/* wlog_head = */ wlog_curr = NULL; /* scan-build */
*pnt2 = 0;
log_text(text, GLOBALS->font_logfile_c_1, pnt);
free_2(pnt);
}
fclose(handle);
log_c = calloc(1, sizeof(struct logfile_instance_t) + strlen(default_text)); /* deliberately not calloc_2, needs to be persistent! */
strcpy(log_c->default_text, default_text);
log_c->window = window;
log_c->text = text;
log_c->next = log_collection;
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
log_c->bold_tag = GLOBALS->bold_tag_logfile_c_2;
log_c->mono_tag = GLOBALS->mono_tag_logfile_c_1;
log_c->size_tag = GLOBALS->size_tag_logfile_c_1;
#else
log_c->font_logfile = GLOBALS->font_logfile_c_1;
#endif
log_collection = log_c;
}
