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 ); }