static void
workspaceview_child_size_cb( Columnview *cview,
GtkAllocation *allocation, Workspaceview *wview )
{
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
Workspacegroup *wsg = workspace_get_workspacegroup( ws );
int right, bottom;
g_assert( IS_WORKSPACEVIEW( wview ) );
/* Compute a new bounding box for our children.
*/
wview->bounding.left = 0;
wview->bounding.top = 0;
wview->bounding.width = 0;
wview->bounding.height = 0;
(void) view_map( VIEW( wview ),
(view_map_fn) workspaceview_child_size_sub,
&wview->bounding, NULL );
wview->bounding.width += 1000;
wview->bounding.height += 1000;
#ifdef DEBUG
{
Column *col = COLUMN( VOBJECT( cview )->iobject );
printf( "workspaceview_child_size_cb: cview %s "
"bb left=%d, top=%d, width=%d, height=%d\n",
IOBJECT( col )->name,
wview->bounding.left,
wview->bounding.top,
wview->bounding.width,
wview->bounding.height );
}
#endif /*DEBUG*/
/* Resize our fixed if necessary.
*/
right = IM_RECT_RIGHT( &wview->bounding );
bottom = IM_RECT_BOTTOM( &wview->bounding );
if( right != wview->width || bottom != wview->height ) {
gtk_widget_set_size_request( GTK_WIDGET( wview->fixed ),
right, bottom );
/* Update the model hints ... it uses bounding to position
* loads and saves.
*/
ws->area = wview->bounding;
filemodel_set_offset( FILEMODEL( wsg ),
ws->area.left, ws->area.top );
}
}
static void
toolkitview_refresh( vObject *vobject )
{
Toolkitview *kview = TOOLKITVIEW( vobject );
Toolkit *kit = TOOLKIT( VOBJECT( kview )->iobject );
Toolkitgroupview *kitgview = kview->kitgview;
GtkWidget *menu = kitgview->menu;
gboolean changed = FALSE;
#ifdef DEBUG
printf( "toolkitview_refresh: " );
iobject_print( VOBJECT( kview )->iobject );
#endif /*DEBUG*/
/* Make a button ready for the sub-menu.
*/
if( !kview->item ) {
kview->item = gtk_menu_item_new_with_label(
IOBJECT( kit )->name );
gtk_menu_shell_insert( GTK_MENU_SHELL( menu ),
kview->item,
ICONTAINER( kit )->pos + TOOLKITVIEW_MENU_OFFSET );
gtk_widget_show( kview->item );
kview->destroy_sid = g_signal_connect( kview->item,
"destroy",
G_CALLBACK( toolkitview_destroy_cb ), kview );
changed = TRUE;
}
if( !kview->menu ) {
iWindow *iwnd = IWINDOW( iwindow_get_root( menu ) );
char path[256];
kview->menu = gtk_menu_new();
gtk_menu_set_accel_group( GTK_MENU( kview->menu ),
iwnd->accel_group );
im_snprintf( path, 256,
"<mainw>/Toolkits/%s", IOBJECT( kit )->name );
gtk_menu_set_accel_path( GTK_MENU( kview->menu ), path );
changed = TRUE;
}
if( changed )
gtk_menu_item_set_submenu( GTK_MENU_ITEM( kview->item ),
kview->menu );
widget_visible( kview->item, ICONTAINER( kit )->children != NULL );
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
static void
expressionview_refresh( vObject *vobject )
{
Expressionview *expressionview = EXPRESSIONVIEW( vobject );
Expression *expression =
EXPRESSION( VOBJECT( expressionview )->iobject );
iText *itext = expression_get_itext( expression );
Row *row = HEAPMODEL( expression )->row;
#ifdef DEBUG
printf( "expressionview_refresh: " );
row_name_print( row );
printf( " (%p)\n", vobject );
#endif /*DEBUG*/
formula_set_edit( expressionview->formula,
row->ws->mode == WORKSPACE_MODE_FORMULA );
if( itext )
formula_set_value_expr( expressionview->formula,
vips_buf_all( &itext->value ), itext->formula );
if( vobject->iobject->caption )
formula_set_caption( expressionview->formula,
vobject->iobject->caption );
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
static void
stringview_refresh( vObject *vobject )
{
Stringview *stringview = STRINGVIEW( vobject );
String *string = STRING( VOBJECT( stringview )->iobject );
#ifdef DEBUG
Row *row = HEAPMODEL( string )->row;
printf( "stringview_refresh: " );
row_name_print( row );
printf( " (%p)\n", vobject );
#endif /*DEBUG*/
if( string->value ) {
char txt[MAX_STRSIZE];
VipsBuf buf = VIPS_BUF_STATIC( txt );
vips_buf_appendsc( &buf, FALSE, string->value );
editview_set_entry( EDITVIEW( stringview ),
"%s", vips_buf_all( &buf ) );
}
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
/* Re-read the text in a tally entry.
*/
static void *
expressionview_scan( View *view )
{
Expressionview *expressionview = EXPRESSIONVIEW( view );
Expression *expression = EXPRESSION(
VOBJECT( expressionview )->iobject );
iText *itext = expression_get_itext( expression );
#ifdef DEBUG
{
Row *row = HEAPMODEL( expression )->row;
printf( "expressionview_scan: " );
row_name_print( row );
printf( "\n" );
}
#endif /*DEBUG*/
if( itext &&
formula_scan( expressionview->formula ) &&
itext_set_formula( itext, expressionview->formula->expr ) ) {
itext_set_edited( itext, TRUE );
/* ... make sure MEMBER_VALUE gets marked dirty too.
*/
expr_dirty( HEAPMODEL( itext )->row->expr,
link_serial_new() );
}
return( VIEW_CLASS( parent_class )->scan( view ) );
}
/* Update our geometry from the fixed widget.
*/
static void
workspaceview_scroll_update( Workspaceview *wview )
{
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
GtkAdjustment *hadj = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
GtkAdjustment *vadj = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
wview->vp.left = hadj->value;
wview->vp.top = vadj->value;
wview->vp.width = hadj->page_size;
wview->vp.height = vadj->page_size;
wview->width = hadj->upper;
wview->height = vadj->upper;
/* Update vp hint in model too.
*/
ws->vp = wview->vp;
#ifdef DEBUG
printf( "workspaceview_scroll_update: %s\n", IOBJECT( ws )->name );
printf( " wview->vp: l=%d, t=%d, w=%d, h=%d; fixed w=%d; h=%d\n",
wview->vp.left, wview->vp.top,
wview->vp.width, wview->vp.height,
wview->width, wview->height );
#endif /*DEBUG*/
}
/* Re-read the text in a tally entry.
*/
static void *
stringview_scan( View *view )
{
Stringview *stringview = STRINGVIEW( view );
String *string = STRING( VOBJECT( stringview )->iobject );
Expr *expr = HEAPMODEL( string )->row->expr;
char value[MAX_STRSIZE];
char value2[MAX_STRSIZE];
#ifdef DEBUG
Row *row = HEAPMODEL( string )->row;
printf( "stringview_scan: " );
row_name_print( row );
printf( "\n" );
#endif /*DEBUG*/
expr_error_clear( expr );
if( !get_geditable_string( EDITVIEW( stringview )->text,
value, MAX_STRSIZE ) ) {
expr_error_set( expr );
return( view );
}
my_strccpy( value2, value );
if( strcmp( string->value, value2 ) != 0 ) {
IM_SETSTR( string->value, value2 );
classmodel_update( CLASSMODEL( string ) ) ;
}
return( VIEW_CLASS( parent_class )->scan( view ) );
}
static void
workspaceview_link( View *view, Model *model, View *parent )
{
Workspaceview *wview = WORKSPACEVIEW( view );
Workspace *ws = WORKSPACE( model );
VIEW_CLASS( parent_class )->link( view, model, parent );
vobject_link( VOBJECT( wview->toolkitbrowser ),
IOBJECT( ws->kitg ) );
vobject_link( VOBJECT( wview->workspacedefs ), IOBJECT( ws ) );
toolkitbrowser_set_workspace( wview->toolkitbrowser, ws );
pane_set_state( wview->rpane, ws->rpane_open, ws->rpane_position );
pane_set_state( wview->lpane, ws->lpane_open, ws->lpane_position );
}
static void
workspaceview_drag_data_received( GtkWidget *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *selection_data,
guint info, guint time )
{
Workspaceview *wview = WORKSPACEVIEW( widget );
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
const char *from_row_path = (const char *) selection_data->data;
Row *from_row;
#ifdef DEBUG
printf( "workspaceview_drag_data_received:\n" );
#endif /*DEBUG*/
/* We seem to rx drag events with x/y relative to the viewport.
*/
x += wview->vp.left;
y += wview->vp.top;
if( info == TARGET_SYMBOL && selection_data->length > 0 &&
selection_data->format == 8 &&
workspaceview_is_background( wview,
GTK_WIDGET( wview->fixed )->window, x, y ) &&
(from_row = row_parse_name( main_workspaceroot->sym,
from_row_path )) ) {
char new_name[MAX_STRSIZE];
Column *col;
char vips_buf_text[256];
VipsBuf buf = VIPS_BUF_STATIC( vips_buf_text );
Symbol *sym;
workspace_column_name_new( ws, new_name );
col = column_new( ws, new_name );
col->x = x;
col->y = y;
workspace_column_select( ws, col );
/* Qualify relative to us. We don't want to embed
* workspace names unless we have to.
*/
row_qualified_name_relative( ws->sym, from_row, &buf );
if( !(sym = workspace_add_def( ws, vips_buf_all( &buf ) )) )
iwindow_alert( widget, GTK_MESSAGE_ERROR );
symbol_recalculate_all();
/* Usually the drag-from row will be selected, very
* annoying. Select the drag-to row.
*/
if( sym &&
sym->expr &&
sym->expr->row )
row_select( sym->expr->row );
}
}
static void
rhsview_refresh( vObject *vobject )
{
Rhsview *rhsview = RHSVIEW( vobject );
Rhs *rhs = RHS( VOBJECT( rhsview )->iobject );
Row *row = HEAPMODEL( rhs )->row;
#ifdef DEBUG
printf( "rhsview_refresh: " );
row_name_print( HEAPMODEL( rhs )->row );
printf( " " );
if( rhs->flags & RHS_GRAPHIC )
printf( "RHS_GRAPHIC " );
if( rhs->flags & RHS_SCOL )
printf( "RHS_SCOL " );
if( rhs->flags & RHS_ITEXT )
printf( "RHS_ITEXT " );
printf( "\n" );
#endif /*DEBUG*/
/* Add/remove children according to rhs->flags.
*/
model_display( rhs->graphic, rhs->flags & RHS_GRAPHIC );
model_display( rhs->scol, rhs->flags & RHS_SCOL );
switch( row->ws->mode ) {
case WORKSPACE_MODE_REGULAR:
model_display( rhs->itext, rhs->flags & RHS_ITEXT );
break;
case WORKSPACE_MODE_FORMULA:
model_display( rhs->itext, TRUE );
break;
case WORKSPACE_MODE_NOEDIT:
/* Only show the text if it's the only this we have for this
* row.
*/
if( rhs->graphic &&
rhs->flags & RHS_GRAPHIC )
model_display( rhs->itext, FALSE );
else if( rhs->scol &&
rhs->flags & RHS_SCOL )
model_display( rhs->itext, FALSE );
else
model_display( rhs->itext,
rhs->flags & RHS_ITEXT );
break;
default:
g_assert( 0 );
}
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
/* Reset edit mode ... go back to whatever is set for this ws.
*/
static void
expressionview_reset( View *view )
{
Expressionview *expressionview = EXPRESSIONVIEW( view );
Expression *expression =
EXPRESSION( VOBJECT( expressionview )->iobject );
Row *row = HEAPMODEL( expression )->row;
expressionview_set_edit( expressionview,
row->ws->mode == WORKSPACE_MODE_FORMULA );
}
/* Toggleview callback.
*/
static void
toggleview_change_cb( GtkWidget *widget, Toggleview *togview )
{
Toggle *tog = TOGGLE( VOBJECT( togview )->iobject );
Classmodel *classmodel = CLASSMODEL( tog );
if( tog->value != GTK_TOGGLE_BUTTON( widget )->active ) {
tog->value = GTK_TOGGLE_BUTTON( widget )->active;
classmodel_update( classmodel );
symbol_recalculate_all();
}
}
/* Get this if ws->mode changes.
*/
static void
rhsview_reset( View *view )
{
Rhsview *rhsview = RHSVIEW( view );
Rhs *rhs = RHS( VOBJECT( rhsview )->iobject );
Row *row = HEAPMODEL( rhs )->row;
model_display( rhs->itext,
row->ws->mode == WORKSPACE_MODE_FORMULA ||
rhs->flags & RHS_ITEXT );
VIEW_CLASS( parent_class )->reset( view );
}
static void
toggleview_refresh( vObject *vobject )
{
Toggleview *togview = TOGGLEVIEW( vobject );
Toggle *tog = TOGGLE( VOBJECT( togview )->iobject );
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON( togview->toggle ), tog->value );
set_glabel( GTK_BIN( togview->toggle )->child, "%s",
IOBJECT( tog )->caption );
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
static void *
subcolumnview_refresh_sub( Rowview *rview, Subcolumnview *sview )
{
Subcolumn *scol = SUBCOLUMN( VOBJECT( sview )->iobject );
Row *row = ROW( VOBJECT( rview )->iobject );
int i;
/* Most predicates need a sym.
*/
if( !row->sym )
return( NULL );
for( i = 0; i <= scol->vislevel; i++ )
if( subcolumn_visibility[i].pred( row ) ) {
rowview_set_visible( rview, TRUE );
sview->nvis++;
break;
}
if( i > scol->vislevel )
rowview_set_visible( rview, FALSE );
return( NULL );
}
static void
toolkitview_link( View *view, Model *model, View *parent )
{
Toolkitview *kview = TOOLKITVIEW( view );
Toolkitgroupview *kitgview = TOOLKITGROUPVIEW( parent );
kview->kitgview = kitgview;
VIEW_CLASS( parent_class )->link( view, model, parent );
#ifdef DEBUG
printf( "toolkitview_link: " );
iobject_print( VOBJECT( kview )->iobject );
#endif /*DEBUG*/
}
static void
workspaceview_refresh( vObject *vobject )
{
Workspaceview *wview = WORKSPACEVIEW( vobject );
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
#ifdef DEBUG
printf( "workspaceview_refresh: %p %s\n", ws, IOBJECT( ws )->name );
#endif /*DEBUG*/
gtk_widget_set_sensitive( GTK_WIDGET( wview ), !ws->locked );
workspace_jump_update( ws, wview->popup_jump );
if( ws->rpane_open && !wview->rpane->open )
pane_animate_open( wview->rpane );
if( !ws->rpane_open && wview->rpane->open )
pane_animate_closed( wview->rpane );
if( ws->lpane_open && !wview->lpane->open )
pane_animate_open( wview->lpane );
if( !ws->lpane_open && wview->lpane->open )
pane_animate_closed( wview->lpane );
if( wview->label ) {
gtk_label_set_text( GTK_LABEL( wview->label ),
IOBJECT( ws )->name );
if( IOBJECT( ws )->caption )
set_tooltip( wview->label,
"%s", IOBJECT( ws )->caption );
if( ws->locked )
gtk_image_set_from_stock( GTK_IMAGE( wview->padlock ),
STOCK_LOCK, GTK_ICON_SIZE_MENU );
else
gtk_image_clear( GTK_IMAGE( wview->padlock ) );
if( ws->errors )
gtk_image_set_from_stock( GTK_IMAGE( wview->alert ),
STOCK_ALERT, GTK_ICON_SIZE_MENU );
else
gtk_image_clear( GTK_IMAGE( wview->alert ) );
}
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
static void
rhsview_link( View *view, Model *model, View *parent )
{
Rhsview *rhsview = RHSVIEW( view );
Rowview *rview = ROWVIEW( parent );
#ifdef DEBUG
printf( "rhsview_link: " );
row_name_print( ROW( VOBJECT( rview )->iobject ) );
printf( "\n" );
#endif /*DEBUG*/
VIEW_CLASS( parent_class )->link( view, model, parent );
rhsview->rview = rview;
}
static void
workspaceview_realize( GtkWidget *widget )
{
#ifdef DEBUG
{
Workspaceview *wview = WORKSPACEVIEW( widget );
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
printf( "workspaceview_realize: %s\n", IOBJECT( ws )->name );
}
#endif /*DEBUG*/
GTK_WIDGET_CLASS( parent_class )->realize( widget );
/* Mark us as a symbol drag-to widget.
*/
set_symbol_drag_type( widget );
}
static void
workspaceview_child_add( View *parent, View *child )
{
Columnview *cview = COLUMNVIEW( child );
Column *column = COLUMN( VOBJECT( cview )->iobject );
Workspaceview *wview = WORKSPACEVIEW( parent );
gtk_signal_connect( GTK_OBJECT( child ), "size_allocate",
GTK_SIGNAL_FUNC( workspaceview_child_size_cb ), parent );
VIEW_CLASS( parent_class )->child_add( parent, child );
/* Pick start xy pos.
*/
workspaceview_pick_xy( wview, &column->x, &column->y );
gtk_fixed_put( GTK_FIXED( wview->fixed ),
GTK_WIDGET( cview ), column->x, column->y );
cview->lx = column->x;
cview->ly = column->y;
}
void
expressionview_activate_cb( GtkWidget *wid, Expressionview *expressionview )
{
Expression *expression =
EXPRESSION( VOBJECT( expressionview )->iobject );
Row *row = HEAPMODEL( expression )->row;
/* Reset edits on this row and all children.
*/
(void) icontainer_map_all( ICONTAINER( row ),
(icontainer_map_fn) heapmodel_clear_edited, NULL );
/* Make sure we scan this text, even if it's not been edited.
*/
view_scannable_register( VIEW( expressionview ) );
workspace_set_modified( row->ws, TRUE );
symbol_recalculate_all();
}
static void *
workspaceview_layout_set_pos( Columnview *cview, WorkspaceLayout *layout )
{
Column *column = COLUMN( VOBJECT( cview )->iobject );
gboolean changed;
changed = FALSE;
/* If this column is being dragged, put the xy we allocate into the
* shadow instead.
*/
if( cview->shadow ) {
if( cview->shadow->lx != layout->out_x ||
cview->shadow->ly != layout->out_y ) {
cview->shadow->lx = layout->out_x;
cview->shadow->ly = layout->out_y;
changed = TRUE;
}
}
else {
if( column->x != layout->out_x ||
column->y != layout->out_y ) {
column->x = layout->out_x;
column->y = layout->out_y;
changed = TRUE;
}
}
layout->out_y += GTK_WIDGET( cview )->allocation.height +
workspaceview_layout_vspacing;
if( changed )
iobject_changed( IOBJECT( column ) );
return( NULL );
}
static gboolean
workspaceview_fixed_event_cb( GtkWidget *widget,
GdkEvent *ev, Workspaceview *wview )
{
gboolean handled = FALSE;
#ifdef EVENT
printf( "workspaceview_fixed_event_cb %d\n", ev->type );
#endif /*EVENT*/
switch( ev->type ) {
case GDK_BUTTON_PRESS:
if( ev->button.button == 1 ) {
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
if( workspaceview_is_background( wview,
ev->button.window,
ev->button.x, ev->button.y ) ) {
workspace_deselect_all( ws );
handled = TRUE;
}
}
else if( ev->button.button == 2 ) {
wview->drag_x = ev->button.x_root + wview->vp.left;
wview->drag_y = ev->button.y_root + wview->vp.top;
workspaceview_set_cursor( wview, IWINDOW_SHAPE_MOVE );
wview->dragging = TRUE;
handled = TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if( ev->button.button == 2 ) {
workspaceview_set_cursor( wview, IWINDOW_SHAPE_NONE );
wview->dragging = FALSE;
handled = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if( wview->dragging && ev->motion.state & GDK_BUTTON2_MASK ) {
/* We're using hints.
*/
widget_update_pointer( GTK_WIDGET( wview ), ev );
workspaceview_scroll_to( wview,
wview->drag_x - ev->motion.x_root,
wview->drag_y - ev->motion.y_root );
handled = TRUE;
}
break;
default:
break;
}
return( handled );
}
static INT CheckVector (GRID *theGrid, VECTOR *v)
{
FORMAT *theFormat;
NODE *theNode;
VECTOR *w;
INT nerr = 0;
/* get format */
theFormat = MGFORMAT(MYMG(theGrid));
if ((FMT_S_MAT_TP(theFormat,DIAGMATRIXTYPE(VTYPE(v)))>0) && (!GHOST(v))) {
if (VSTART(v) == NULL) {
UserWriteF(PFMT "ERROR: no diagonal matrix vec=" VINDEX_FMTX "\n",
me,VINDEX_PRTX(v));
nerr++;
}
else if (!MDIAG(VSTART(v))) {
UserWriteF(PFMT "ERROR: VSTART no diagonal matrix vec="
VINDEX_FMTX "\n",
me,VINDEX_PRTX(v));
nerr++;
}
}
/* check flags locally */
if (NEW_DEFECT(v) != (VCLASS(v)>=2)) {
UserWriteF(PFMT "ERROR: classes not match vec="
VINDEX_FMTX " NEW_DEFECT %d VCLASS %d\n",
me,VINDEX_PRTX(v),NEW_DEFECT(v),VCLASS(v));
nerr++;
}
if (FINE_GRID_DOF(v) != ((VCLASS(v)>=2)&&(VNCLASS(v)<=1))) {
UserWriteF(PFMT "ERROR: classes not match vec="
VINDEX_FMTX " FINE_GRID_DOF %d VNCLASS %d VCLASS %d\n",
me,VINDEX_PRTX(v),FINE_GRID_DOF(v),VNCLASS(v),VCLASS(v));
nerr++;
}
if (FINE_GRID_DOF(v))
if (FULLREFINELEVEL(MYMG(theGrid)) > GLEVEL(theGrid)) {
UserWriteF(PFMT "ERROR: FULLREFINELEVEL too large vec="
VINDEX_FMTX " FINE_GRID_DOF %d FULLREFINELEVEL %d\n",
me,VINDEX_PRTX(v),FINE_GRID_DOF(v),
FULLREFINELEVEL(MYMG(theGrid)));
nerr++;
}
if (VOTYPE(v) == NODEVEC) {
theNode = (NODE *) VOBJECT(v);
if (theNode == NULL) {
if (GLEVEL(theGrid) >= 0) {
UserWriteF(PFMT "ERROR: nodevector has no NODE vec="
VINDEX_FMTX " \n",
me,VINDEX_PRTX(v));
nerr++;
}
}
else {
if (OBJT(theNode) != NDOBJ) {
UserWriteF(PFMT "ERROR: nodevector has no NODE object vec="
VINDEX_FMTX " OBJT %d\n",
me,VINDEX_PRTX(v),OBJT(theNode));
nerr++;
}
if (NTYPE(theNode) == CORNER_NODE) {
theNode = (NODE *)NFATHER(theNode);
if (theNode != NULL) {
w = NVECTOR(theNode);
if (w == NULL) {
UserWriteF(PFMT "ERROR:"
" cornernode vector has no father vec="
VINDEX_FMTX "\n",
me,VINDEX_PRTX(v));
nerr++;
}
if (VNCLASS(w) != VCLASS(v)) {
UserWriteF(PFMT "ERROR:"
" VCLASS and VNCLASS not matches vec="
VINDEX_FMTX " VCLASS %d father vec "
VINDEX_FMTX " VNCLASS %d\n",
me,VINDEX_PRTX(v),VCLASS(v),
VINDEX_PRTX(w),VNCLASS(w));
nerr++;
}
}
}
}
}
return(nerr);
}
INT l_nlgs (NP_NLGS *nlgs, NP_NL_ASSEMBLE *ass, GRID *grid, const DOUBLE *damp,
VECDATA_DESC *x, VECDATA_DESC *v, MATDATA_DESC *M,
VECDATA_DESC *d)
{
VECTOR *vec,*w,*first_vec;
NODE *theNode;
MULTIGRID *mg;
INT level;
INT rtype,ctype,myindex,error;
register MATRIX *mat;
register SHORT *tmpptr,*dcomp,*xcomp,*vcomp;
register SHORT i;
register SHORT n;
DEFINE_VD_CMPS(cy);
DEFINE_MD_CMPS(m);
DOUBLE r[MAX_SINGLE_VEC_COMP];
mg = nlgs->smoother.iter.base.mg;
level = GLEVEL(grid);
first_vec = FIRSTVECTOR(grid);
L_VLOOP__CLASS(vec,first_vec,ACTIVE_CLASS)
{
rtype = VTYPE(vec);
/* get node */
theNode = (NODE*)VOBJECT(vec);
n = VD_NCMPS_IN_TYPE(v,rtype);
if (n == 0) continue;
dcomp = VD_CMPPTR_OF_TYPE(d,rtype);
xcomp = VD_CMPPTR_OF_TYPE(x,rtype);
vcomp = VD_CMPPTR_OF_TYPE(v,rtype);
myindex = VINDEX(vec);
/* local Jacobi matrix */
if ((*ass->NLNAssembleMatrix)(ass,level,level,theNode,x,d,v,M,&error)) {
error = __LINE__;
REP_ERR_RETURN(error);
}
/* get defect */
for (i=0; i<n; i++)
r[i] = VVALUE(vec,dcomp[i]);
/* rhs */
for (ctype=0; ctype<=NVECTYPES; ctype++)
if (MD_ROWS_IN_RT_CT(M,rtype,ctype)>0)
{
SET_CMPS_22(cy,v,m,M,rtype,ctype,tmpptr);
s0 = s1 = 0.0;
for (mat=MNEXT(VSTART(vec)); mat!=NULL; mat=MNEXT(mat))
if (((VTYPE(w=MDEST(mat))==ctype) && (VCLASS(w)>=ACTIVE_CLASS)) && (myindex>VINDEX(w)))
MATMUL_22(s,mat,m,w,cy);
r[0] -= s0;
r[1] -= s1;
}
/* solve */
if (MySolveSmallBlock(n,VD_CMPPTR_OF_TYPE(v,rtype),VVALPTR(vec),
MD_MCMPPTR_OF_RT_CT(M,rtype,rtype),
MVALPTR(VSTART(vec)),r)!=0)
return (__LINE__);
/* damp */
for (i=0; i<n; i++)
VVALUE(vec,vcomp[i]) *= damp[i];
/* update solution */
for (i=0; i<n; i++)
VVALUE(vec,xcomp[i]) -= VVALUE(vec,vcomp[i]);
}
static void
subcolumnview_refresh( vObject *vobject )
{
Subcolumnview *sview = SUBCOLUMNVIEW( vobject );
Subcolumn *scol = SUBCOLUMN( VOBJECT( sview )->iobject );
int model_rows = icontainer_get_n_children( ICONTAINER( scol ) );
int old_nvis = sview->nvis;
gboolean editable = scol->top_col->ws->mode != WORKSPACE_MODE_NOEDIT;
#ifdef DEBUG
printf( "subcolumnview_refresh\n" );
#endif /*DEBUG*/
if( sview->rows != model_rows ) {
sview->rows = model_rows;
if( sview->rows )
gtk_table_resize( GTK_TABLE( sview->table ),
sview->rows, 4 );
#ifdef DEBUG
printf( "subcolumnview_refresh: resize to %d rows\n",
sview->rows );
#endif /*DEBUG*/
}
/* Top-level subcolumns look different in no-edit mode.
*/
if( scol->is_top && editable ) {
gtk_alignment_set_padding( GTK_ALIGNMENT( sview->align ),
0, 0, 0, 0 );
gtk_table_set_row_spacings( GTK_TABLE( sview->table ), 0 );
gtk_table_set_col_spacings( GTK_TABLE( sview->table ), 0 );
}
else if( scol->is_top && !editable ) {
gtk_alignment_set_padding( GTK_ALIGNMENT( sview->align ),
5, 5, 5, 5 );
gtk_table_set_row_spacings( GTK_TABLE( sview->table ), 5 );
gtk_table_set_col_spacings( GTK_TABLE( sview->table ), 5 );
}
/* Nested subcols: we just change the left indent.
*/
if( !scol->is_top && editable ) {
gtk_alignment_set_padding( GTK_ALIGNMENT( sview->align ),
0, 0, 0, 0 );
}
else if( !scol->is_top && !editable ) {
gtk_alignment_set_padding( GTK_ALIGNMENT( sview->align ),
0, 0, 15, 0 );
}
sview->nvis = 0;
(void) view_map( VIEW( sview ),
(view_map_fn) subcolumnview_refresh_sub, sview, NULL );
if( sview->nvis != old_nvis ) {
view_resize( VIEW( sview ) );
iobject_changed( IOBJECT( scol->top_col ) );
}
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
