XttSevHist::XttSevHist( void *parent_ctx,
const char *name,
pwr_tOid *xn_oid,
pwr_tOName *xn_aname,
sevcli_tCtx xn_scctx,
int *sts,
bool sevhistobject) :
xnav(parent_ctx), gcd(0), curve(0), rows(0), vsize(0), timerid(0), close_cb(0), help_cb(0),
first_scan(1), scctx(xn_scctx), oid(xn_oid[0]), time_low_old(0), time_high_old(0), sevhistobject(sevhistobject)
{
strncpy( aname, xn_aname[0], sizeof(aname));
get_data( sts, pwr_cNTime, pwr_cNTime);
if ( EVEN(*sts)) return;
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
}
void WFoeMotif::set_title()
{
Arg args[2];
if ( function == EDIT) {
pwr_tOName new_title;
strcpy( new_title, "*** ");
cdh_StrncpyCutOff( &new_title[4], name, sizeof(new_title)-4, 0);
XtSetArg(args[0],XmNtitle, new_title);
XtSetValues( parent_wid, args, 1);
}
else if ( function == VIEW) {
pwr_tOName new_title;
strcpy( new_title, name);
XtSetArg(args[0],XmNtitle, new_title);
XtSetValues( parent_wid, args, 1);
}
}
XttTCurve::XttTCurve( void *parent_ctx,
const char *name,
pwr_tAttrRef *xn_arefv,
int xn_color_theme,
int *sts) :
xnav(parent_ctx), gcd(0), curve(0), rows(0), vsize(0), timerid(0), close_cb(0), help_cb(0),
get_select_cb(0), first_scan(1), time_low_old(0), time_high_old(0), color_theme(xn_color_theme)
{
pwr_tTime from, to;
memset( &tc, 0, sizeof(tc));
if ( xn_arefv == 0 || xn_arefv[0].Objid.vid == 0) {
aref_cnt = 0;
gcd = new GeCurveData( curve_eDataType_DsTrend);
*sts = 1;
return;
}
// Count number of curves
for ( aref_cnt = 0; xn_arefv[aref_cnt].Objid.vid != 0; aref_cnt++) ;
if ( aref_cnt > XTT_TCURVE_MAX)
aref_cnt = XTT_TCURVE_MAX;
memcpy( arefv, xn_arefv, aref_cnt * sizeof(arefv[0]));
time_Period( time_ePeriod_OneMinute, &from, &to, 0, 0);
if ( aref_cnt == 1) {
get_data( sts, from, to);
if ( EVEN(*sts)) return;
}
else {
get_multidata( sts, from, to);
if ( EVEN(*sts)) return;
}
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
}
WGeMotif::WGeMotif( Widget wge_parent_wid, void *wge_parent_ctx, char *wge_name, char *wge_filename,
int wge_scrollbar, int wge_menu, int wge_navigator, int wge_width, int wge_height,
int x, int y, char *object_name, int wge_modal = 0) :
WGe(wge_parent_ctx, wge_name, wge_filename, wge_scrollbar, wge_menu, wge_navigator, wge_width,
wge_height, x, y, object_name, wge_modal),
parent_wid(wge_parent_wid), value_dialog(0), set_focus_disabled(0), focus_timerid(0)
{
pwr_tFileName uid_filename = {"$pwr_exe/wb_wge.uid"};
char *uid_filename_p = uid_filename;
Arg args[20];
pwr_tStatus sts;
char title[300];
int i;
MrmHierarchy s_DRMh;
MrmType dclass;
Widget wge_widget;
char wname[] = "Proview/R Ge";
static char translations[] =
"<ConfigureNotify>: resize()\n\
<FocusIn>: wge_inputfocus()";
static XtTranslations compiled_translations = NULL;
static XtActionsRec actions[] =
{
{(char*) "wge_inputfocus", (XtActionProc) action_inputfocus},
{(char*) "resize", (XtActionProc) action_resize},
};
static MrmRegisterArg reglist[] = {
{(char*) "wge_ctx", 0 },
{(char*) "wge_activate_exit",(caddr_t)activate_exit },
{(char*) "wge_activate_zoom_in",(caddr_t)activate_zoom_in },
{(char*) "wge_activate_zoom_out",(caddr_t)activate_zoom_out },
{(char*) "wge_activate_zoom_reset",(caddr_t)activate_zoom_reset },
{(char*) "wge_activate_help",(caddr_t)activate_help },
{(char*) "wge_create_graph_form",(caddr_t)create_graph_form },
{(char*) "wge_create_menu",(caddr_t)create_menu },
{(char*) "wge_create_value_input",(caddr_t)create_value_input },
{(char*) "wge_activate_value_input",(caddr_t)activate_value_input },
{(char*) "wge_activate_confirm_ok",(caddr_t)activate_confirm_ok },
{(char*) "wge_activate_confirm_cancel",(caddr_t)activate_confirm_cancel },
{(char*) "wge_create_message_dia",(caddr_t)create_message_dia }
};
static int reglist_num = (sizeof reglist / sizeof reglist[0]);
dcli_translate_filename( uid_filename, uid_filename);
// Create object context
strcpy( filename, wge_filename);
strcpy( name, wge_name);
// command_cb = command_cb;
// help_cb = help_cb;
// close_cb = close_cb;
// is_authorized_cb = is_authorized_cb;
// Motif
MrmInitialize();
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
reglist[0].value = (caddr_t) this;
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename);
// Save the context structure in the widget
i = 0;
XtSetArg(args[i], XmNuserData, (XtPointer) this);i++;
XtSetArg(args[i],XmNdeleteResponse, XmDO_NOTHING);i++;
toplevel = XtCreatePopupShell( title,
topLevelShellWidgetClass, parent_wid, args, i);
MrmRegisterNames(reglist, reglist_num);
sts = MrmFetchWidgetOverride( s_DRMh, (char*) "wge_window", toplevel,
wname, args, 1, &wge_widget, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch %s\n", wname);
sts = MrmFetchWidget(s_DRMh, (char*) "input_dialog", toplevel,
&value_dialog, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch input dialog\n");
sts = MrmFetchWidget(s_DRMh, (char*) "confirm_dialog", toplevel,
&confirm_widget, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch confirm dialog\n");
sts = MrmFetchWidget(s_DRMh, (char*) "message_dialog", toplevel,
&message_dia_widget, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch message dialog\n");
MrmCloseHierarchy(s_DRMh);
if (compiled_translations == NULL)
XtAppAddActions( XtWidgetToApplicationContext(toplevel),
actions, XtNumber(actions));
if (compiled_translations == NULL)
compiled_translations = XtParseTranslationTable(translations);
XtOverrideTranslations( wge_widget, compiled_translations);
i = 0;
if ( width == 0 || height == 0)
{
XtSetArg(args[i],XmNwidth,600);i++;
XtSetArg(args[i],XmNheight,500);i++;
}
else
{
XtSetArg(args[i],XmNwidth,width);i++;
XtSetArg(args[i],XmNheight,height);i++;
XtSetArg(args[i], XmNminAspectX, width); i++;
XtSetArg(args[i], XmNminAspectY, height); i++;
XtSetArg(args[i], XmNmaxAspectX, width); i++;
XtSetArg(args[i], XmNmaxAspectY, height); i++;
}
if ( !(x == 0 && y == 0))
{
XtSetArg(args[i],XmNx, x);i++;
XtSetArg(args[i],XmNy, y);i++;
}
XtSetValues( toplevel, args,i);
XtManageChild( wge_widget);
if ( !menu)
XtUnmanageChild( menu_widget);
graph = new GraphMotif( this, graph_form, "Plant",
&grow_widget, &sts, "pwrp_exe:", graph_eMode_Runtime,
scrollbar, 1, object_name, 0, 0);
((Graph *)graph)->message_cb = &message;
((Graph *)graph)->close_cb = &graph_close_cb;
((Graph *)graph)->init_cb = &graph_init_cb;
((Graph *)graph)->change_value_cb = &change_value_cb;
((Graph *)graph)->confirm_cb = &confirm_cb;
((Graph *)graph)->message_dialog_cb = &message_dialog_cb;
((Graph *)graph)->command_cb = &wge_command_cb;
((Graph *)graph)->is_authorized_cb = &wge_is_authorized_cb;
XtPopup( toplevel, XtGrabNone);
if ( navigator)
{
// Create navigator popup
i = 0;
XtSetArg(args[i],XmNallowShellResize, TRUE); i++;
XtSetArg(args[i],XmNallowResize, TRUE); i++;
XtSetArg(args[i],XmNwidth,200);i++;
XtSetArg(args[i],XmNheight,200);i++;
XtSetArg(args[i],XmNx,500);i++;
XtSetArg(args[i],XmNy,500);i++;
XtSetArg(args[i],XmNdeleteResponse, XmDO_NOTHING);i++;
nav_shell = XmCreateDialogShell( grow_widget, (char*) "Navigator",
args, i);
XtManageChild( nav_shell);
((GraphMotif *)graph)->create_navigator( nav_shell);
// XtManageChild( nav_widget);
XtRealizeWidget( nav_shell);
((Graph *)graph)->set_nav_background_color();
}
// Connect the window manager close-button to exit
flow_AddCloseVMProtocolCb( toplevel,
(XtCallbackProc)activate_exit, this);
}
XttGeGtk::XttGeGtk( GtkWidget *xg_parent_wid, void *xg_parent_ctx, const char *xg_name,
const char *xg_filename, int xg_scrollbar, int xg_menu, int xg_navigator,
int xg_width, int xg_height, int x, int y, double scan_time,
const char *object_name, int use_default_access, unsigned int access,
unsigned int options, void *basewidget,
int (*xg_command_cb) (void *, char *, void *),
int (*xg_get_current_objects_cb) (void *, pwr_sAttrRef **, int **),
int (*xg_is_authorized_cb) (void *, unsigned int)) :
XttGe( xg_parent_ctx, xg_name, xg_filename, xg_scrollbar, xg_menu, xg_navigator, xg_width,
xg_height, x, y, scan_time, object_name, use_default_access, access, options,
xg_command_cb, xg_get_current_objects_cb, xg_is_authorized_cb),
parent_wid(xg_parent_wid), nav_shell(0), value_dialog(0), confirm_widget(0), message_dia_widget(0)
{
int window_width = 600;
int window_height = 500;
GdkGeometry geometry;
pwr_tStatus sts;
GtkMenuBar *menu_bar;
char title[300];
if ( xg_width != 0 && xg_height != 0) {
window_width = xg_width;
window_height = xg_height;
}
else {
sts = Graph::get_dimension( filename, "pwrp_exe:", &window_width, &window_height);
if ( EVEN(sts)) {
window_width = 600;
window_height = 500;
}
}
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
char *titleutf8 = g_convert( title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
// Gtk
if ( !(options & ge_mOptions_Embedded)) {
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", titleutf8,
NULL);
g_free( titleutf8);
geometry.min_aspect = gdouble(window_width)/window_height;
geometry.max_aspect = gdouble(window_width)/window_height * 1.02;
gtk_window_set_geometry_hints( GTK_WINDOW(toplevel), GTK_WIDGET(toplevel),
&geometry, GDK_HINT_ASPECT);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
if ( basewidget) {
gtk_window_set_transient_for(GTK_WINDOW(toplevel), GTK_WINDOW(basewidget));
}
}
else {
toplevel = parent_wid;
}
if ( xg_menu) {
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// View menu
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(activate_zoom_reset), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
GtkWidget *view = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
}
graph_form = gtk_vbox_new( FALSE, 0);
graph = new GraphGtk( this, graph_form, "Plant",
&grow_widget, &sts, "pwrp_exe:", graph_eMode_Runtime,
scrollbar, 1, object_name, use_default_access, access);
// graph->set_scantime( scan_time);
graph->message_cb = &message_cb;
graph->close_cb = &graph_close_cb;
graph->init_cb = &graph_init_cb;
graph->change_value_cb = &ge_change_value_cb;
graph->confirm_cb = &confirm_cb;
graph->message_dialog_cb = &message_dialog_cb;
graph->command_cb = &ge_command_cb;
graph->display_in_xnav_cb = &ge_display_in_xnav_cb;
graph->is_authorized_cb = &ge_is_authorized_cb;
graph->get_current_objects_cb = &ge_get_current_objects_cb;
graph->popup_menu_cb = &ge_popup_menu_cb;
graph->call_method_cb = &ge_call_method_cb;
graph->sound_cb = &ge_sound_cb;
graph->eventlog_cb = &ge_eventlog_cb;
//g_signal_connect( graph_form, "check_resize", G_CALLBACK(action_resize), this);
g_signal_connect( ((GraphGtk *)graph)->grow_widget, "size_allocate", G_CALLBACK(action_resize), this);
if ( xg_menu)
gtk_box_pack_start( GTK_BOX(graph_form), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(graph_form), GTK_WIDGET(grow_widget), TRUE, TRUE, 0);
if ( !(options & ge_mOptions_Embedded)) {
gtk_container_add( GTK_CONTAINER(toplevel), graph_form);
gtk_widget_show_all( toplevel);
if ( navigator) {
// Create navigator popup
nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"title", "Navigator",
NULL);
g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
((GraphGtk *)graph)->create_navigator( nav_shell);
gtk_container_add( GTK_CONTAINER(nav_shell), ((GraphGtk *)graph)->nav_widget);
gtk_widget_show_all( nav_shell);
((Graph *)graph)->set_nav_background_color();
}
if ( !(x == 0 && y == 0)) {
// Set position
gtk_window_move( GTK_WINDOW(toplevel), x, y);
}
if ( options & ge_mOptions_FullScreen)
gtk_window_fullscreen( GTK_WINDOW(toplevel));
else if ( options & ge_mOptions_Maximize)
gtk_window_maximize( GTK_WINDOW(toplevel)); // TODO
else if ( options & ge_mOptions_FullMaximize)
gtk_window_maximize( GTK_WINDOW(toplevel));
else if ( options & ge_mOptions_Iconify)
gtk_window_iconify( GTK_WINDOW(toplevel));
else if ( options & ge_mOptions_Invisible)
g_object_set( toplevel, "visible", FALSE, NULL);
}
else {
gtk_widget_set_size_request( graph_form, window_width, window_height);
}
}
XttFast::XttFast( void *parent_ctx,
char *name,
pwr_sAttrRef *fast_arp,
int *sts) :
xnav(parent_ctx), fast_cnt(0), timerid(0), close_cb(0), help_cb(0), first_scan(1),
axis_configured(false)
{
pwr_sAttrRef aref = pwr_cNAttrRef;
pwr_tAName fast_name;
pwr_tAName attr_name;
pwr_sClass_DsFastCurve fp;
int i, j;
*sts = XNAV__SUCCESS;
// Get current status of the fast objects
i = 0;
aref = *fast_arp;
if ( cdh_ObjidIsNull( aref.Objid)) {
*sts = XNAV__FASTCONFIG;
return;
}
*sts = gdh_AttrrefToName( &aref, fast_name, sizeof(fast_name),
cdh_mNName);
if (EVEN(*sts)) return;
*sts = gdh_GetObjectInfo( fast_name, &fp, sizeof(fp));
if ( EVEN(*sts)) return;
max_points = fp.NoOfPoints;
fast_function = fp.Function;
strcpy( attr_name, fast_name);
strcat( attr_name, ".TriggTime");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &trigg_time_attr);
if ( fast_function & fast_mFunction_BeforeTrigg) {
strcpy( attr_name, fast_name);
strcat( attr_name, ".TriggIndex");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &trigg_index_attr);
strcpy( attr_name, fast_name);
strcat( attr_name, ".FirstIndex");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &first_index_attr);
strcpy( attr_name, fast_name);
strcat( attr_name, ".LastIndex");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &last_index_attr);
}
// Create data for time axis
gcd = new GeCurveData( curve_eDataType_DsTrend);
gcd->x_data[0] = (double *) malloc( 8 * max_points);
strcpy( gcd->x_name, "Time");
gcd->x_axis_type[0] = curve_eAxis_x;
memcpy( &time_buff, &fp.TimeBuffer, sizeof(time_buff));
fast_cnt = 0;
for ( i = 0; i < FAST_CURVES; i++) {
if ( fp.CurveValid[i]) {
gcd->y_data[fast_cnt] = (double *) calloc( 1, 8 * max_points);
gcd->y_axis_type[fast_cnt] = curve_eAxis_y;
memcpy( &buff[fast_cnt], &fp.Buffers[i], sizeof(buff[0]));
type[fast_cnt] = (pwr_eType) fp.AttributeType[i];
fast_idx[i] = fast_cnt;
curve_idx[fast_cnt] = i;
*sts = gdh_AttrrefToName( &fp.Attribute[i], attr_name,
sizeof(attr_name), cdh_mNName);
if (EVEN(*sts)) continue;
strcpy( gcd->y_name[fast_cnt], attr_name);
fast_cnt++;
}
}
if ( !fast_cnt) {
*sts = XNAV__NOVALIDCURVE;
free(gcd);
gcd = 0;
return;
}
// Subscribe to object
strcpy( attr_name, fast_name);
strcat( attr_name, ".New");
*sts = gdh_RefObjectInfo( attr_name, (pwr_tAddress *)&new_p,
&new_subid, sizeof(pwr_tBoolean));
if ( EVEN(*sts)) return;
for ( i = 0; i < fast_cnt; i++) {
switch( type[i]) {
case pwr_eType_Float32:
case pwr_eType_Int32:
case pwr_eType_UInt32:
element_size[i] = 4;
break;
case pwr_eType_Float64:
case pwr_eType_Int64:
case pwr_eType_UInt64:
element_size[i] = 8;
break;
case pwr_eType_Int16:
case pwr_eType_UInt16:
element_size[i] = 2;
break;
case pwr_eType_Int8:
case pwr_eType_UInt8:
element_size[i] = 1;
break;
default:
element_size[i] = 4;
}
gcd->rows[i] = max_points;
}
gcd->cols = fast_cnt;
axis_configured = true;
for ( i = 0; i < FAST_CURVES; i++) {
if ( fp.CurveValid[i]) {
j = fast_idx[i];
if ( fp.YMinValue[i] != fp.YMaxValue[i])
gcd->scale( gcd->y_axis_type[j], gcd->y_value_type[j],
fp.YMinValue[i], fp.YMaxValue[i],
&gcd->y_min_value_axis[j], &gcd->y_max_value_axis[j],
&gcd->y_trend_lines[j], &gcd->y_axis_lines[j], &gcd->y_axis_linelongq[j],
&gcd->y_axis_valueq[j], gcd->y_format[j], &gcd->y_axis_width[j], 1, 1);
else
axis_configured = false;
}
}
if ( fp.Active)
first_scan = 0;
fast_scan( this);
gcd->select_color( 0);
if ( strcmp( fp.Title, "") != 0)
strcpy( title, fp.Title);
else
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
// timerid = XtAppAddTimeOut(
// XtWidgetToApplicationContext(parent_widget), 1000,
// (XtTimerCallbackProc)fast_scan, this);
}
GeCurveMotif::GeCurveMotif( void *gc_parent_ctx,
Widget parent_widget,
char *curve_name,
char *filename,
GeCurveData *curve_data,
int pos_right) :
GeCurve( gc_parent_ctx, curve_name, filename, curve_data, pos_right)
{
char uid_filename[120] = {"xtt_curve.uid"};
char *uid_filename_p = uid_filename;
Arg args[20];
pwr_tStatus sts;
int i;
MrmHierarchy s_DRMh;
MrmType dclass;
Widget ge_curve_widget;
char name[] = "PwR GeCurve";
static MrmRegisterArg reglist[] = {
{(char*) "gec_ctx", 0 },
{(char*) "gec_activate_exit",(caddr_t)activate_exit },
{(char*) "gec_activate_configure",(caddr_t)activate_configure },
{(char*) "gec_activate_print",(caddr_t)activate_print },
{(char*) "gec_activate_zoomin",(caddr_t)activate_zoomin },
{(char*) "gec_activate_zoomout",(caddr_t)activate_zoomout },
{(char*) "gec_activate_zoomreset",(caddr_t)activate_zoomreset },
{(char*) "gec_activate_background",(caddr_t)activate_background },
{(char*) "gec_activate_showname",(caddr_t)activate_showname },
{(char*) "gec_activate_filledcurves",(caddr_t)activate_filledcurves },
{(char*) "gec_activate_xlimits",(caddr_t)activate_xlimits },
{(char*) "gec_activate_help",(caddr_t)activate_help },
{(char*) "gec_create_pane",(caddr_t)create_pane },
{(char*) "gec_create_growform",(caddr_t)create_growform },
{(char*) "gec_create_nameform",(caddr_t)create_nameform },
{(char*) "gec_create_curveform",(caddr_t)create_curveform },
{(char*) "gec_create_minmax_textmin",(caddr_t)create_minmax_textmin },
{(char*) "gec_create_minmax_textmax",(caddr_t)create_minmax_textmax },
{(char*) "gec_activate_minmax_ok",(caddr_t)activate_minmax_ok }
};
static int reglist_num = (sizeof reglist / sizeof reglist[0]);
Lng::get_uid( uid_filename, uid_filename);
// Motif
MrmInitialize();
cdh_StrncpyCutOff( title, curve_name, sizeof(title), 1);
reglist[0].value = (caddr_t) this;
toplevel = XtCreatePopupShell(title,
topLevelShellWidgetClass, parent_widget, args, 0);
// Save the context structure in the widget
XtSetArg (args[0], XmNuserData, (XtPointer) this);
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename);
MrmRegisterNames(reglist, reglist_num);
sts = MrmFetchWidgetOverride( s_DRMh, (char*) "ge_curve_window", toplevel,
name, NULL, 0, &ge_curve_widget, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch %s\n", name);
sts = MrmFetchWidget(s_DRMh, (char*) "minmax_dialog", toplevel,
&minmax_widget, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch input dialog\n");
MrmCloseHierarchy(s_DRMh);
i = 0;
XtSetArg(args[i],XmNwidth,800);i++;
XtSetArg(args[i],XmNheight,600);i++;
XtSetArg(args[i], XmNdeleteResponse, XmDO_NOTHING);i++;
XtSetValues( toplevel ,args,i);
XtManageChild( ge_curve_widget);
Widget w;
grownames_main_widget = ScrolledGrowCreate( nameform_widget,
(char*) "GeCurveNames", NULL,
0, init_grownames_cb, this, &w);
i = 0;
XtSetArg(args[i],XmNwidth,200);i++;
XtSetValues( grownames_main_widget, args,i);
XtManageChild( grownames_main_widget);
growaxis_main_widget = GrowCreate( axisform_widget,
(char*) "GeCurveAxis", NULL,
0, init_growaxis_cb, this);
i = 0;
XtSetArg(args[i],XmNwidth,200);i++;
XtSetValues( growaxis_main_widget, args,i);
XtManageChild( growaxis_main_widget);
growcurve_main_widget = CurveCreate( curveform_widget,
(char*) "GeCurve", NULL,
0, init_growcurve_cb, this);
XtManageChild( growcurve_main_widget);
i = 0;
XtSetArg(args[i],XmNwidth,200);i++;
XtSetArg(args[i],XmNheight,200);i++;
XtSetArg(args[i],XmNpaneMinimum,75);i++;
XtSetArg(args[i],XmNpaneMaximum,100);i++;
nav_widget = CurveCreateNav( pane_widget, (char*) "navigator",
args, i, growcurve_main_widget);
XtManageChild( nav_widget);
XtPopup( toplevel, XtGrabNone);
XtRealizeWidget( toplevel);
wow = new CoWowMotif( toplevel);
// Connect the window manager close-button to exit
flow_AddCloseVMProtocolCb( toplevel,
(XtCallbackProc)activate_exit, this);
}
GeCurveGtk::GeCurveGtk( void *gc_parent_ctx,
GtkWidget *parent_widget,
char *curve_name,
char *filename,
GeCurveData *curve_data,
int pos_right,
int gc_width,
int gc_height,
unsigned int gc_options,
int gc_color_theme,
void *basewidget) :
GeCurve( gc_parent_ctx, curve_name, filename, curve_data, pos_right,
gc_width, gc_height, gc_options, gc_color_theme),
minmax_widget(0), export_widget(0), disable_timecombo_callback(0), clock_cursor(0)
{
int window_width = 900;
int window_height = 700;
const int names_height = 150;
const int nav_height = 120;
pwr_tFileName fname;
float height_scale = 1;
int nonav = 0;
if ( gc_width != 0)
window_width = gc_width;
if ( gc_height != 0) {
height_scale = (float)gc_height / window_height;
window_height = gc_height;
}
cdh_StrncpyCutOff( title, curve_name, sizeof(title), 1);
// Gtk
if ( !(options & curve_mOptions_Embedded)) {
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", CoWowGtk::convert_utf8(title),
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
}
else {
toplevel = parent_widget;
}
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
menu_add = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Add"));
g_signal_connect( menu_add, "activate",
G_CALLBACK(activate_madd), this);
GtkWidget *file_refresh = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Refresh"));
g_signal_connect( file_refresh, "activate",
G_CALLBACK(activate_configure), this);
gtk_widget_add_accelerator( file_refresh, "activate", accel_g, 'r', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *file_print = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock( "gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
menu_export = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Export"));
g_signal_connect(menu_export, "activate", G_CALLBACK(activate_export), this);
menu_new = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_New"));
g_signal_connect(menu_new, "activate", G_CALLBACK(activate_new), this);
menu_save = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("S_ave"));
g_signal_connect(menu_save, "activate", G_CALLBACK(activate_save), this);
gtk_widget_add_accelerator( menu_save, "activate", accel_g,'s',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
menu_open = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Open"));
g_signal_connect(menu_open, "activate", G_CALLBACK(activate_open), this);
menu_snapshot = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Snapshot"));
g_signal_connect(menu_snapshot, "activate", G_CALLBACK(activate_snapshot), this);
gtk_widget_add_accelerator( menu_snapshot, "activate", accel_g,'n',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget *file_close = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock( "gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
gtk_widget_add_accelerator( file_close, "activate", accel_g,'w', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_add);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_refresh);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_new);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_open);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_save);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_snapshot);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_export);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// View menu
GtkWidget *view_zoom_in = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock( "gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(activate_zoomin), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock( "gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(activate_zoomout), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock( "gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(activate_zoomreset), this);
GtkWidget *view_background = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Background Color"));
g_signal_connect( view_background, "activate",
G_CALLBACK(activate_background), this);
GtkWidget *view_showname = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Names"));
g_signal_connect( view_showname, "activate",
G_CALLBACK(activate_showname), this);
gtk_widget_add_accelerator( view_showname, "activate", accel_g,
'w', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_filledcurves = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Filled Curves"));
g_signal_connect( view_filledcurves, "activate",
G_CALLBACK(activate_filledcurves), this);
GtkWidget *view_xlimits = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_X-Axis Limits"));
g_signal_connect( view_xlimits, "activate",
G_CALLBACK(activate_xlimits), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_background);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_showname);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_filledcurves);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_xlimits);
GtkWidget *view = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoomin), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in, CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoomout), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out, CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoomreset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset, CoWowGtk::translate_utf8("Zoom reset"), "");
GtkWidget *tools_page_left = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_page_left.png");
gtk_container_add( GTK_CONTAINER(tools_page_left),
gtk_image_new_from_file( fname));
g_signal_connect(tools_page_left, "clicked", G_CALLBACK(activate_page_left), this);
g_object_set( tools_page_left, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_page_left, CoWowGtk::translate_utf8("Page left"), "");
GtkWidget *tools_scroll_left = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_left.png");
gtk_container_add( GTK_CONTAINER(tools_scroll_left),
gtk_image_new_from_file( fname));
g_signal_connect(tools_scroll_left, "clicked", G_CALLBACK(activate_scroll_left), this);
g_object_set( tools_scroll_left, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_scroll_left, CoWowGtk::translate_utf8("Scroll left"), "");
GtkWidget *tools_scroll_right = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_right.png");
gtk_container_add( GTK_CONTAINER(tools_scroll_right),
gtk_image_new_from_file( fname));
g_signal_connect(tools_scroll_right, "clicked", G_CALLBACK(activate_scroll_right), this);
g_object_set( tools_scroll_right, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_scroll_right, CoWowGtk::translate_utf8("Scroll right"), "");
GtkWidget *tools_page_right = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_page_right.png");
gtk_container_add( GTK_CONTAINER(tools_page_right),
gtk_image_new_from_file( fname));
g_signal_connect(tools_page_right, "clicked", G_CALLBACK(activate_page_right), this);
g_object_set( tools_page_right, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_page_right, CoWowGtk::translate_utf8("Page right"), "");
tools_snapshot = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_snapshot.png");
gtk_container_add( GTK_CONTAINER(tools_snapshot),
gtk_image_new_from_file( fname));
g_signal_connect(tools_snapshot, "clicked", G_CALLBACK(activate_snapshot), this);
g_object_set( tools_snapshot, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_snapshot, CoWowGtk::translate_utf8("Snapshot"), "");
tools_add = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_add.png");
gtk_container_add( GTK_CONTAINER(tools_add),
gtk_image_new_from_file( fname));
g_signal_connect(tools_add, "clicked", G_CALLBACK(activate_add), this);
g_object_set( tools_add, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_add, CoWowGtk::translate_utf8("Add"), "");
// Time box
GtkToolbar *timetools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *sea_time_start_label = gtk_label_new( CoWowGtk::translate_utf8("Time"));
gtk_widget_set_size_request( sea_time_start_label, 70, -1);
gtk_misc_set_alignment( GTK_MISC(sea_time_start_label), 0.0, 0.5);
gtk_toolbar_append_widget( timetools, sea_time_start_label, "", "");
// Time option menu
timebox_timecombo = gtk_combo_box_new_text();
for ( int i = 0; curve_timecombo_text[i].text[0]; i++)
gtk_combo_box_append_text( GTK_COMBO_BOX(timebox_timecombo),
CoWowGtk::translate_utf8(curve_timecombo_text[i].text));
g_signal_connect(timebox_timecombo, "changed", G_CALLBACK(activate_timecombo), this);
gtk_toolbar_append_widget( timetools, timebox_timecombo, 0, "");
timebox_start_time = gtk_entry_new();
gtk_widget_set_size_request( timebox_start_time, 160, -1);
gtk_toolbar_append_widget( timetools, timebox_start_time, "", "");
GtkWidget *sea_time_stop_label = gtk_label_new( CoWowGtk::translate_utf8("-"));
gtk_widget_set_size_request( sea_time_stop_label, 20, -1);
gtk_toolbar_append_widget( timetools, sea_time_stop_label, "", "");
timebox_stop_time = gtk_entry_new();
gtk_widget_set_size_request( timebox_stop_time, 160, -1);
gtk_toolbar_append_widget( timetools, timebox_stop_time, "", "");
GtkWidget *timebox_prev_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_left.png");
gtk_container_add( GTK_CONTAINER(timebox_prev_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_prev_period, "clicked", G_CALLBACK(activate_prev_period), this);
g_object_set( timebox_prev_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_prev_period, CoWowGtk::translate_utf8("Previous period"), "");
GtkWidget *timebox_next_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_right.png");
gtk_container_add( GTK_CONTAINER(timebox_next_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_next_period, "clicked", G_CALLBACK(activate_next_period), this);
g_object_set( timebox_next_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_next_period, CoWowGtk::translate_utf8("Next period"), "");
GtkWidget *timebox_increase_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_up.png");
gtk_container_add( GTK_CONTAINER(timebox_increase_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_increase_period, "clicked", G_CALLBACK(activate_increase_period), this);
g_object_set( timebox_increase_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_increase_period, CoWowGtk::translate_utf8("Increase period"), "");
GtkWidget *timebox_decrease_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_down.png");
gtk_container_add( GTK_CONTAINER(timebox_decrease_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_decrease_period, "clicked", G_CALLBACK(activate_decrease_period), this);
g_object_set( timebox_decrease_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_decrease_period, CoWowGtk::translate_utf8("Decrease period"), "");
GtkWidget *timebox_reload = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_reload.png");
gtk_container_add( GTK_CONTAINER(timebox_reload),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_reload, "clicked", G_CALLBACK(activate_reload), this);
g_object_set( timebox_reload, "can-focus", FALSE, NULL);
// gtk_toolbar_append_widget( timetools, timebox_reload, CoWowGtk::translate_utf8("Update"), "");
GtkWidget *timebox_add = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_add.png");
gtk_container_add( GTK_CONTAINER(timebox_add),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_add, "clicked", G_CALLBACK(activate_add), this);
g_object_set( timebox_add, "can-focus", FALSE, NULL);
// gtk_toolbar_append_widget( timetools, timebox_add, CoWowGtk::translate_utf8("Add curve item"), "");
GtkWidget *timebox_remove = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_remove.png");
gtk_container_add( GTK_CONTAINER(timebox_remove),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_remove, "clicked", G_CALLBACK(activate_remove), this);
g_object_set( timebox_remove, "can-focus", FALSE, NULL);
// gtk_toolbar_append_widget( timetools, timebox_remove, CoWowGtk::translate_utf8("Remove selected curve"), "");
GtkToolbar *curvebuttonbox = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
//GtkWidget *curvebuttonbox = gtk_hbox_new( FALSE, 0);
gtk_toolbar_append_widget( curvebuttonbox, timebox_reload, CoWowGtk::translate_utf8("Update curve"), "");
gtk_toolbar_append_widget( curvebuttonbox, timebox_add, CoWowGtk::translate_utf8("Add curve item"), "");
sea_timebox = gtk_hbox_new( FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), sea_time_start_label, FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), timebox_timecombo, FALSE, FALSE, 10);
// gtk_box_pack_start( GTK_BOX(sea_timebox), timebox_start_time, FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), sea_time_stop_label, FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), timebox_stop_time, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(sea_timebox), GTK_WIDGET(timetools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(sea_timebox), gtk_hseparator_new(), FALSE, FALSE, 10);
gtk_box_pack_start( GTK_BOX(sea_timebox), GTK_WIDGET(curvebuttonbox), FALSE, FALSE, 0);
GtkWidget *w;
grownames_main_widget = scrolledgrowwidgetgtk_new( init_grownames_cb, this, &w);
if ( nonav)
growcurve_main_widget = scrolledcurvewidgetgtk_new( init_growcurve_cb, this, &w);
else
growcurve_main_widget = curvewidgetgtk_new( init_growcurve_cb, this);
growaxis_main_widget = growwidgetgtk_new( init_growaxis_cb, this);
if (!nonav)
nav_widget = curvenavwidgetgtk_new( growcurve_main_widget);
GtkWidget *hbox = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(hbox), growaxis_main_widget, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(hbox), growcurve_main_widget, TRUE, TRUE, 0);
gtk_widget_show_all( hbox);
GtkWidget *vpaned1 = gtk_vpaned_new();
GtkWidget *vpaned2 = gtk_vpaned_new();
gtk_paned_add1( GTK_PANED(vpaned1), grownames_main_widget);
gtk_paned_add2( GTK_PANED(vpaned1), vpaned2);
gtk_widget_show_all( vpaned1);
gtk_paned_pack1( GTK_PANED(vpaned2), hbox, TRUE, TRUE);
if ( !nonav)
gtk_paned_pack2( GTK_PANED(vpaned2), nav_widget, FALSE, TRUE);
gtk_widget_show_all( vpaned2);
GtkWidget *tools_box = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(tools_box), GTK_WIDGET(tools), FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(tools_box), GTK_WIDGET(sea_timebox), FALSE, FALSE, 0);
vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools_box), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(sea_timebox), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(vpaned1), TRUE, TRUE, 0);
if ( !(options & curve_mOptions_Embedded)) {
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
}
else
gtk_widget_set_size_request( vbox, window_width, window_height);
gtk_paned_set_position( GTK_PANED(vpaned1), names_height * height_scale);
gtk_paned_set_position( GTK_PANED(vpaned2), (window_height - names_height - nav_height - 50) * height_scale);
g_object_set( sea_timebox, "visible", FALSE, NULL);
g_object_set( menu_new, "visible", FALSE, NULL);
g_object_set( menu_save, "visible", FALSE, NULL);
g_object_set( menu_open, "visible", FALSE, NULL);
g_object_set( menu_snapshot, "visible", FALSE, NULL);
g_object_set( menu_export, "visible", FALSE, NULL);
g_object_set( tools_snapshot, "visible", FALSE, NULL);
g_object_set( tools_add, "visible", FALSE, NULL);
wow = new CoWowGtk( toplevel);
gtk_combo_box_set_active( GTK_COMBO_BOX(timebox_timecombo), 2);
if ( !(options & curve_mOptions_Embedded)) {
if ( options & curve_mOptions_FullScreen)
gtk_window_fullscreen( GTK_WINDOW(toplevel));
else if ( options & curve_mOptions_Maximize)
gtk_window_maximize( GTK_WINDOW(toplevel)); // TODO
else if ( options & curve_mOptions_FullMaximize)
gtk_window_maximize( GTK_WINDOW(toplevel));
else if ( options & curve_mOptions_Iconify)
gtk_window_iconify( GTK_WINDOW(toplevel));
else if ( options & curve_mOptions_Invisible)
g_object_set( toplevel, "visible", FALSE, NULL);
if ( basewidget)
gtk_window_set_transient_for(GTK_WINDOW(toplevel), GTK_WINDOW(basewidget));
}
}
WGeGtk::WGeGtk( GtkWidget *wge_parent_wid, void *wge_parent_ctx, char *wge_name, char *wge_filename,
int wge_scrollbar, int wge_menu, int wge_navigator, int wge_width, int wge_height,
int x, int y, char *object_name, int wge_modal = 0) :
WGe(wge_parent_ctx, wge_name, wge_filename, wge_scrollbar, wge_menu, wge_navigator, wge_width,
wge_height, x, y, object_name, wge_modal),
parent_wid(wge_parent_wid), nav_shell(0), value_dialog(0), confirm_widget(0)
{
int window_width = 600;
int window_height = 500;
GdkGeometry geometry;
pwr_tStatus sts;
GtkMenuBar *menu_bar;
char title[300];
if ( wge_width != 0 && wge_height != 0) {
window_width = wge_width;
window_height = wge_height;
}
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
// Gtk
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", title,
NULL);
CoWowGtk::SetWindowIcon( toplevel);
geometry.min_aspect = geometry.max_aspect = gdouble(window_width)/window_height;
gtk_window_set_geometry_hints( GTK_WINDOW(toplevel), GTK_WIDGET(toplevel),
&geometry, GDK_HINT_ASPECT);
if ( !(x == 0 && y == 0)) {
// Set position...
}
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
if ( wge_menu) {
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// View menu
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(activate_zoom_reset), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
GtkWidget *view = gtk_menu_item_new_with_mnemonic("_View");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
}
graph_form = gtk_vbox_new( FALSE, 0);
graph = new GraphGtk( this, graph_form, "Plant",
&grow_widget, &sts, "pwrp_exe:", graph_eMode_Runtime,
scrollbar, 1, object_name, 0, 0);
((Graph *)graph)->message_cb = &message;
((Graph *)graph)->close_cb = &graph_close_cb;
((Graph *)graph)->init_cb = &graph_init_cb;
((Graph *)graph)->change_value_cb = &change_value_cb;
((Graph *)graph)->confirm_cb = &confirm_cb;
((Graph *)graph)->message_dialog_cb = &message_dialog_cb;
((Graph *)graph)->command_cb = &wge_command_cb;
((Graph *)graph)->is_authorized_cb = &wge_is_authorized_cb;
//g_signal_connect( graph_form, "check_resize", G_CALLBACK(action_resize), this);
g_signal_connect( ((GraphGtk *)graph)->grow_widget, "size_allocate", G_CALLBACK(action_resize), this);
if ( wge_menu)
gtk_box_pack_start( GTK_BOX(graph_form), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(graph_form), GTK_WIDGET(grow_widget), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), graph_form);
gtk_widget_show_all( toplevel);
if ( navigator) {
// Create navigator popup
nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"title", "Navigator",
NULL);
g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
((GraphGtk *)graph)->create_navigator( nav_shell);
gtk_container_add( GTK_CONTAINER(nav_shell), ((GraphGtk *)graph)->nav_widget);
gtk_widget_show_all( nav_shell);
((Graph *)graph)->set_nav_background_color();
}
}
XAttMotif::XAttMotif( Widget xa_parent_wid,
void *xa_parent_ctx,
pwr_sAttrRef *xa_objar,
int xa_advanced_user,
int *xa_sts) :
XAtt( xa_parent_ctx, xa_objar, xa_advanced_user, xa_sts),
parent_wid(xa_parent_wid), set_focus_disabled(0),
value_current_recall(0)
{
char uid_filename[120] = {"xtt_xatt.uid"};
char *uid_filename_p = uid_filename;
Arg args[20];
pwr_tStatus sts;
pwr_tAName title;
int i;
MrmHierarchy s_DRMh;
MrmType dclass;
char name[] = "Proview/R Navigator";
static char translations[] =
"<FocusIn>: xatt_inputfocus()\n";
static XtTranslations compiled_translations = NULL;
static XtActionsRec actions[] =
{
{(char*) "xatt_inputfocus", (XtActionProc) action_inputfocus}
};
static MrmRegisterArg reglist[] = {
{(char*) "xatt_ctx", 0 },
{(char*) "xatt_activate_exit",(caddr_t)activate_exit },
{(char*) "xatt_activate_display_object",(caddr_t)activate_display_object },
{(char*) "xatt_activate_show_cross",(caddr_t)activate_show_cross },
{(char*) "xatt_activate_open_classgraph",(caddr_t)activate_open_classgraph },
{(char*) "xatt_activate_open_plc",(caddr_t)activate_open_plc },
{(char*) "xatt_activate_change_value",(caddr_t)activate_change_value },
{(char*) "xatt_activate_close_changeval",(caddr_t)activate_close_changeval },
{(char*) "xatt_activate_help",(caddr_t)activate_help },
{(char*) "xatt_create_msg_label",(caddr_t)create_msg_label },
{(char*) "xatt_create_cmd_prompt",(caddr_t)create_cmd_prompt },
{(char*) "xatt_create_cmd_input",(caddr_t)create_cmd_input },
{(char*) "xatt_create_cmd_scrolledinput",(caddr_t)create_cmd_scrolledinput },
{(char*) "xatt_create_cmd_scrolled_ok",(caddr_t)create_cmd_scrolled_ok },
{(char*) "xatt_create_cmd_scrolled_ca",(caddr_t)create_cmd_scrolled_ca },
{(char*) "xatt_create_xattnav_form",(caddr_t)create_xattnav_form },
{(char*) "xatt_activate_cmd_scrolledinput",(caddr_t)activate_cmd_input },
{(char*) "xatt_activate_cmd_scrolled_ok",(caddr_t)activate_cmd_scrolled_ok },
{(char*) "xatt_activate_cmd_scrolled_ca",(caddr_t)activate_cmd_scrolled_ca }
};
static int reglist_num = (sizeof reglist / sizeof reglist[0]);
// for ( i = 0; i < int(sizeof(value_recall)/sizeof(value_recall[0])); i++)
// value_recall[i][0] = 0;
Lng::get_uid( uid_filename, uid_filename);
// Create object context
// attrctx->close_cb = close_cb;
// attrctx->redraw_cb = redraw_cb;
// Motif
MrmInitialize();
*xa_sts = gdh_AttrrefToName( &objar, title, sizeof(title), cdh_mNName);
if ( EVEN(*xa_sts)) return;
cdh_StrncpyCutOff( title, title, 100, 1);
reglist[0].value = (caddr_t) this;
// Save the context structure in the widget
i = 0;
XtSetArg (args[i], XmNuserData, (XtPointer) this);
i++;
XtSetArg( args[i], XmNdeleteResponse, XmDO_NOTHING);
i++;
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename);
MrmRegisterNames(reglist, reglist_num);
parent_wid = XtCreatePopupShell( title,
topLevelShellWidgetClass, parent_wid, args, i);
sts = MrmFetchWidgetOverride( s_DRMh, (char*) "xatt_window", parent_wid,
name, args, 1, &toplevel, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch %s\n", name);
MrmCloseHierarchy(s_DRMh);
if (compiled_translations == NULL)
XtAppAddActions( XtWidgetToApplicationContext(toplevel),
actions, XtNumber(actions));
if (compiled_translations == NULL)
compiled_translations = XtParseTranslationTable(translations);
XtOverrideTranslations( toplevel, compiled_translations);
i = 0;
XtSetArg(args[i],XmNwidth,420);
i++;
XtSetArg(args[i],XmNheight,600);
i++;
XtSetValues( toplevel ,args,i);
XtManageChild( toplevel);
XtUnmanageChild( cmd_input);
XtUnmanageChild( cmd_scrolledinput);
XtUnmanageChild( cmd_scrolled_ok);
XtUnmanageChild( cmd_scrolled_ca);
xattnav = new XAttNavMotif( (void *)this, xattnav_form, xattnav_eType_Object,
"Plant", &objar, xa_advanced_user, &brow_widget, &sts);
xattnav->message_cb = &message_cb;
xattnav->change_value_cb = &change_value_cb;
xattnav->popup_menu_cb = &xatt_popup_menu_cb;
xattnav->is_authorized_cb = &xatt_is_authorized_cb;
XtPopup( parent_wid, XtGrabNone);
// Connect the window manager close-button to exit
flow_AddCloseVMProtocolCb( parent_wid,
(XtCallbackProc)activate_exit, this);
*xa_sts = XATT__SUCCESS;
}
