function [out1,out2,out3,out4,out5,out6] = ...  %-*-matlab-*-
    kalibond(action,in1,in2,in3,in4,in5,in6)
% KALIBOND    Kali's bondgraph-program
%    kalibond(action)
%
%  action == 
%    'start' ...... initialize
%    'bond' ....... draw a bond
%    'elem' ....... draw an element
%    'matrices' ... load the state-space-matrices' names
%    'outvec' ..... load the output-vector
%
%  Johann Kallinovsky
%  Diplomarbeit
%

global TYP_XX;
global TYP_SE;
global TYP_SF;
global TYP_C;
global TYP_I;
global TYP_R;
global TYP_1;
global TYP_0;
global TYP_TF;
global TYP_GY;
global TYP_KEINER_DA;
global TRUE;
global FALSE;
global EFFORT;
global FLOW;
global WEG_VOM_KNOTEN;
global AKAUSAL;
global HIN_ZUM_KNOTEN;
global STATUS_KONFLIKT;
global STATUS_ENDE_AUSBR;
global STATUS_WEG;
global STATUS_HIN;
global F_start;
global F_elem;
global F_bond;
global F_matrizen;
global F_outvec;
global F_nelem;
global F_nbond;
global F_move_zwipu;
global F_moved_zwipu;
global F_move_elem;
global F_moved_elem;
global F_axis_clicked;
global F_bond_clicked;
global F_element_clicked;
global F_zoom_in;
global F_zoom_out;
global F_zoom_max;
global F_normiere;
global F_save1;
global F_save_as;
global F_save2;
global F_load1;
global F_load2;
global F_load3;
global F_message_on;
global F_message_off;
global F_clear1;
global F_clear2;
global F_del_kaus;
global F_modified_on;
global F_modified_off;
global F_if_modified;
global F_edit_on;
global F_edit_off;
global F_button_cb;
global F_menu_opt;
global F_pruefe;
global F_check_par;
global F_par_cb;
global F_ask_matrizen;
global F_cancel_matrizen;
global F_get_matrizen;
global F_ask_ausgang;
global F_cancel_ausgang;
global F_get_ausgang;
global F_imp_antw;
global F_spr_antw;
global F_kausaliere;
global F_kalikaus;
global F_rechne1;
global F_rechne2;
%global F_parse;
global F_p_despace;
global F_p_str2vec;
global F_print1;
global F_print2;
global F_print_su;
global F_pr_cb;
global F_ex_eps;
global F_quit1;
global F_quit2;
global F_v2str;
global F_elem_num;
global F_label;
global F_acc;
global F2_start;
global F2_bgfk;
global F2_scapna;
global F2_vib;
global F2_vtb;
global F2_zuwei_se;
global F2_zuwei_sf;
global F2_zuwei_c;
global F2_zuwei_i;
global F2_zuwei_r;
global F2_zuwei_ib;
global F2_bsua;
global F2_bak;
global F2_adk;
global F2_analy_sf;
global F2_analy_se;
global F2_analy_c;
global F2_analy_i;
global F2_analy_r;
global F2_analy_0;
global F2_analy_1;
global F2_analy_tf;
global F2_analy_gy;

F_start = 1;

if(nargin<1)
  action = 'start';
end

if(isstr(action))
  if(strcmp(action,'start'))
    action = F_start;
  elseif(strcmp(action,'elem'))
    action = F_elem;
  elseif(strcmp(action,'bond'))
    action = F_bond;
  elseif(strcmp(action,'matrices'))
    action = F_matrizen;
  elseif(strcmp(action,'outvec'))
    action = F_outvec;
  else
    disp('*** KaliBond: unknown action ***');
  end
end

global LKAUS;
global LPFEIL;
global LELEMS;
global LELEMS2;
global LBONDS;
global LBONDS2;
global BONDLIST;
global FILENAME;
global PATHNAME;
global MATR_NAM;
global MATR_OUT;
global OUT_VEC;
global BILD_NAME;
global H_BILD;
global H_MESSAGE;
global H_EDIT;
global H_M_SAVE;
global H_M_KAUS;
global H_M_RECHNE;
global H_M_SIMUL;
global H_M_SANTW;
global H_M_IANTW;
global H_M_O_W;
global LIN_ABST;
global ZOOM_HIST;
global DRAWMODE;
global DRAWTMP;
global DRAWTMP2;
global DRAWLEVEL;
global ZUSTAND_PRUEFE;
global Z_SCHNITZER;
global Z_PARAMETER;
global Z_KAUSOK;
global Z_KAUSVOLL;
global MODIFIED;
global MATRIX_A;
global MATRIX_B;
global MATRIX_C;
global MATRIX_D;
global MATRIX_E;
global MATRIX_F;
global THE_PRINTER;

if(action == F_start)
  %%%%%%%%%%%%%%%%%%%%%%%%
  % Alles initialisieren %
  %%%%%%%%%%%%%%%%%%%%%%%% 
  

  TYP_XX            =  0;
  TYP_SE            =  1;
  TYP_SF            =  2;
  TYP_C             =  3;
  TYP_I             =  4;
  TYP_R             =  5;
  TYP_1             =  6;
  TYP_0             =  7;
  TYP_TF            =  8;
  TYP_GY            =  9;
  TYP_KEINER_DA     = 10;
  TRUE              =  1;
  FALSE             =  0;
  EFFORT            = +1;
  FLOW              = -1;
  WEG_VOM_KNOTEN    = +1;
  AKAUSAL           =  0;
  HIN_ZUM_KNOTEN    = -1;
  STATUS_KONFLIKT   =  1;
  STATUS_ENDE_AUSBR =  2;
  STATUS_WEG        =  3;
  STATUS_HIN        =  4;
  F_start           =  1;  % !!!
  F_elem            =  2;
  F_bond            =  3;
  F_matrizen        =  4;
  F_outvec          =  5;
  F_nelem           =  6;
  F_nbond           =  7;
  F_move_zwipu      =  8;
  F_moved_zwipu     =  9;
  F_move_elem       = 10;
  F_moved_elem      = 11;
  F_axis_clicked    = 12;
  F_bond_clicked    = 13;
  F_element_clicked = 14;
  F_zoom_in         = 15;
  F_zoom_out        = 16;
  F_zoom_max        = 17;
  F_normiere        = 18;
  F_save1           = 19;
  F_save_as         = 20;
  F_save2           = 21;
  F_load1           = 22;
  F_load2           = 23;
  F_load3           = 24;
  F_message_on      = 25;
  F_message_off     = 26;
  F_clear1          = 27;
  F_clear2          = 28;
  F_del_kaus        = 29;
  F_modified_on     = 30;
  F_modified_off    = 31;
  F_if_modified     = 32;
  F_edit_on         = 33;
  F_edit_off        = 34;
  F_button_cb       = 35;
  F_menu_opt        = 36;
  F_pruefe          = 37;
  F_check_par       = 38;
  F_par_cb          = 39;
  F_ask_matrizen    = 40;
  F_cancel_matrizen = 41;
  F_get_matrizen    = 42;
  F_ask_ausgang     = 43;
  F_cancel_ausgang  = 44;
  F_get_ausgang     = 45;
  F_imp_antw        = 46;
  F_spr_antw        = 47;
  F_kausaliere      = 48;
  F_kalikaus        = 49;
  F_rechne1         = 50;
  F_rechne2         = 51;
%  F_parse           = 52;
  F_p_despace       = 53;
  F_p_str2vec       = 54;
  F_print1          = 55;
  F_print2          = 56;
  F_print_su        = 57;
  F_pr_cb           = 58;
  F_ex_eps          = 59;
  F_quit1           = 60;
  F_quit2           = 61;
  F_v2str           = 62;
  F_elem_num        = 63;
  F_label           = 64;
  F_acc             = 65;
  F2_start          =  1;
  F2_bgfk           =  2;
  F2_scapna         =  4;
  F2_vib            =  5;
  F2_vtb            =  6;
  F2_zuwei_se       =  7;
  F2_zuwei_sf       =  8;
  F2_zuwei_c        =  9;
  F2_zuwei_i        = 10;
  F2_zuwei_r        = 11;
  F2_zuwei_ib       = 12;
  F2_bsua           = 13;
  F2_bak            = 14;
  F2_adk            = 15;
  F2_analy_sf       = 16;
  F2_analy_se       = 17;
  F2_analy_c        = 18;
  F2_analy_i        = 19;
  F2_analy_r        = 20;
  F2_analy_0        = 21;
  F2_analy_1        = 22;
  F2_analy_tf       = 23;
  F2_analy_gy       = 24;
  
  
  if(exist('H_BILD'))
    disp('KaliBond already running');
    disp(['... or for some bizarre reason the global variable' ...
	  ' H_BILD not cleared']);
    return;
  end
 
  LKAUS = [];
  LPFEIL = [];
  LELEMS = [];
  LELEMS2 = [];
  LBONDS = [];
  LBONDS2 = [];
  
  FILENAME = 0;
  PATHNAME = 0;
  
  THE_PRINTER = [];
  
  MATR_NAM = ['A';'B';'C';'D';'E';'F'];
  MATR_OUT = ['[A,B,C,D,E,F]'];
  OUT_VEC = blanks(0);
  ZOOM_HIST = [];
  LIN_ABST = 2;     % Abstand des Bondes von des Elementes Mittelpunkt
  
  BILD_NAME = 'KaliBond:  ';
  H_BILD = figure('numbertitle','off', ...
      'nextplot','new', ...
      'menubar','none', ...
      'name',[BILD_NAME 'NoName']);

  pos_frac = 0.11;  % wieviel Platz sind die Radiobuttons
  pos_anz = 14;     % wieviele Positionen gibt es
  pos = [(1-pos_frac)*ones(pos_anz,1) ...
	  [(1-1/pos_anz):-(1/pos_anz):0]' ...
	  pos_frac*ones(pos_anz,1) ...
	  (1/pos_anz)*ones(pos_anz,1)];
  
  
  message_pos = [0 0.9 (1-pos_frac) 0.1];
  edit_pos = [0 0.9 0.1 0.05; ...
      0.1 0.9 (1-pos_frac-0.1) 0.05];
  
  gruen = [0 1 0];
  H_MESSAGE = uicontrol('style','text', ...
      'units','normalized', ...
      'position',message_pos, ...
      'string','', ...
      'foregroundcolor',gruen, ...
      'backgroundcolor',get(gcf,'color'));
  
  H_EDIT(1) = uicontrol('style','text', ...
      'units','normalized', ...
      'position',edit_pos(1,:), ...
      'visible','off');
  H_EDIT(2) = uicontrol('style','edit', ...
      'units','normalized', ...
      'position',edit_pos(2,:), ...
      'visible','off');
  
  axis_button_down = ['kalibond(',int2str(F_axis_clicked),');'];
  axis('equal');
  axis([0 35 0 35]);
  set(gca,'position',[0.04 0.08 (1-pos_frac-0.05) 0.8], ...
      'nextplot','new', ...
      'xcolor',get(gcf,'color'), ...
      'ycolor',get(gcf,'color'), ...
      'buttondownfcn',axis_button_down);
  
  % Kreiere die Radiobuttons
  anz_radio = 14;
  h_radio = [];
  radio_text = str2mat('bond', ...
      ['SE'; ...
      'SF'], ...
      ['C'; ...
      'I'; ...
      'R'; ...
      '0'; ...
      '1'], ...
      ['TF'; ...
      'GY'], ...
      'par', ...
      'causa', ...
      'move', ...
      'del');
  
  for i=1:anz_radio
    h_radio = [h_radio; ...
	uicontrol('units','normalized', ...
	    'position',pos(i,:), ...
	    'string',radio_text(i,:), ...
	    'callback',['kalibond(',int2str(F_button_cb),');'], ...
	    'style','radiobutton', ...
	    'backgroundcolor',[1 1 1]*0.701961, ...
	    'visible','off')];
  end
  
  % Speichere die Handels der anderen Radiobuttons in UserData
  for i=1:anz_radio
    h_rel_radio = h_radio;
    h_rel_radio(i) = [];
    set(h_radio(i),'userdata',h_rel_radio);
  end
  
  % Jetzt die Men"us
  
  h_m_file = uimenu('label',kalibond(F_label,'&File'));
  
  uimenu('label',kalibond(F_label,'&Drawmode-on'), ...
      'accelerator',kalibond(F_acc,'d'), ...
      'callback',['kalibond(',int2str(F_edit_on),');'], ...
      'userdata',h_radio);
  
  h_m_acti = uimenu('label',kalibond(F_label,'&Actions'));
  
  h_m_opt = uimenu('label',kalibond(F_label,'&Options'));

  h_m_zoom = uimenu('label',kalibond(F_label,'&Zoom'));
  
  uimenu(h_m_file,'label',kalibond(F_label,'&New'), ...
      'accelerator',kalibond(F_acc,'n'), ...
      'callback',['kalibond(',int2str(F_clear1),');']);
    
  uimenu(h_m_file,'label',kalibond(F_label,'&Load ...'), ...
      'accelerator',kalibond(F_acc,'f'), ...
      'separator','on', ...
      'callback',['kalibond(',int2str(F_load1),');']);
  
  H_M_SAVE = uimenu(h_m_file,'label',kalibond(F_label,'&Save'), ...
      'accelerator',kalibond(F_acc,'s'), ...
      'enable','off', ...
      'callback',['kalibond(',int2str(F_save1),');']);
  
  uimenu(h_m_file,'label',kalibond(F_label,'Save &As ...'), ...
      'accelerator',kalibond(F_acc,'w'), ...
      'callback',['kalibond(',int2str(F_save_as),');']);
  
  uimenu(h_m_file,'label',kalibond(F_label,'&Print ...'), ...
      'accelerator',kalibond(F_acc,'p'), ...
      'separator','on', ...
      'callback',['kalibond(',int2str(F_print1),');']);
  
  uimenu(h_m_file,'label',kalibond(F_label,'P&rinter Setup ...'), ...
      'callback',['kalibond(',int2str(F_print_su),');']);
  
  h_m_export = uimenu(h_m_file, ...
      'label',kalibond(F_label,'&Export ...'));
  
  uimenu(h_m_file,'label',kalibond(F_label,'E&xit KaliBond'), ...
      'accelerator',kalibond(F_acc,'c'), ...
      'separator','on', ...
      'callback',['kalibond(',int2str(F_quit1),');']);
  
  uimenu(h_m_export, ...
      'label',kalibond(F_label,'Encapsulated &Postscript'), ...
      'callback',['kalibond(',int2str(F_ex_eps),',''mono'')';]);
  
  uimenu(h_m_export, ...
      'label',kalibond(F_label,'Encapsulated &Colour Postscript'), ...
      'callback',['kalibond(',int2str(F_ex_eps),',''colour'')';]);
  
  uimenu(h_m_acti, ...
      'label',kalibond(F_label,'&Delete Causal Strokes'), ...
      'callback',['kalibond(',int2str(F_del_kaus),');']);
  
  H_M_KAUS = uimenu(h_m_acti, ...
      'label',kalibond(F_label,'&Assign Causality'), ...
      'enable','off', ...
      'callback',['kalibond(',int2str(F_kausaliere),');']);
  
  uimenu(h_m_acti, ...
      'label',kalibond(F_label,'State-Space &Matrices'' Names ...'), ...
      'accelerator',kalibond(F_acc,'m'), ...
      'separator','on', ...
      'callback',['kalibond(',int2str(F_ask_matrizen),');']);
  
  uimenu(h_m_acti, ...
      'label',kalibond(F_label,'&Output-Vector ...'), ...
      'accelerator',kalibond(F_acc,'v'), ...
      'callback',['kalibond(',int2str(F_ask_ausgang),');']);
  
  H_M_RECHNE = uimenu(h_m_acti, ...
      'label',kalibond(F_label,'&Compute'), ...
      'enable','off', ...
      'callback',[MATR_OUT ' = kalibond(',int2str(F_rechne1),')']);
  
  H_M_SIMUL = uimenu(h_m_acti, ...
      'label',kalibond(F_label,'&Simulate ...'), ...
      'enable','off', ...
      'separator','on');
  
  H_M_IANTW = uimenu(H_M_SIMUL, ...
      'label',kalibond(F_label,'&Impulse-Respone'), ...
      'enable','off', ...
      'callback',['kalibond(',int2str(F_imp_antw),');']);
  
  H_M_SANTW = uimenu(H_M_SIMUL, ...
      'label',kalibond(F_label,'&Step-Respone'), ...
      'enable','off', ...
      'callback',['kalibond(',int2str(F_spr_antw),');']);
  
  h_m_opti(1) = uimenu(h_m_opt, ...
      'label',kalibond(F_label,'show about &Structure'), ...
      'accelerator',kalibond(F_acc,'1'));
  h_m_opti(2) = uimenu(h_m_opt, ...
      'label',kalibond(F_label,'show &Integration Causalities'), ...
      'accelerator',kalibond(F_acc,'2'));
  h_m_opti(3) = uimenu(h_m_opt, ...
      'label',kalibond(F_label,'show Causale &Conflicts'), ...
      'accelerator',kalibond(F_acc,'3'));
  h_m_opti(4) = uimenu(h_m_opt, ...
      'label',kalibond(F_label,'&Off'), ...
      'separator','on', ...
      'checked','on');
  H_M_O_W = h_m_opti(3);
  for i=1:size(h_m_opti,2)
    andere = h_m_opti;
    andere(i) = [];
    set(h_m_opti(i),'userdata',andere, ...
	'callback',['kalibond(',int2str(F_menu_opt),',' int2str(i) ');']);
  end
  
  uimenu(h_m_zoom, ...
      'label',kalibond(F_label,'&Zoom'), ...
      'accelerator',kalibond(F_acc,'o'), ...
      'callback',['kalibond(',int2str(F_zoom_in),');']);
  
  uimenu(h_m_zoom, ...
      'label',kalibond(F_label,'&Un-Zoom'), ...
      'accelerator',kalibond(F_acc,'u'), ...
      'callback',['kalibond(',int2str(F_zoom_out),');']);
  
  uimenu(h_m_zoom, ...
      'label',kalibond(F_label,'Zoom &max'), ...
      'separator','on', ...
      'callback',['kalibond(',int2str(F_zoom_max),');']);

  
elseif(action == F_bond)
  %%%%%%%%%%%%%%%%%%%%
  % Zeichne den Bond %
  %%%%%%%%%%%%%%%%%%%%
  %
  %Aufruf: kalibond('bond',nummer,nro_a,nro_z,zwi_pu,'Kausalit"at')
  %      | kalibond('bond',nummer,nro_a,nro_z,'Kausalit"at')
  %      | kalibond('bond',nummer,nro_a,nro_z,zwi_pu)
  %      | kalibond('bond',nummer,nro_a,nro_z)
  %      | kalibond('bond','redraw',bond_nro,zwi_pu)
  %      | kalibond('bond','redraw',bond_nro)
  %      | kalibond('bond','redraw',bond_nro,'Kausalit"at')
  %
  %  nummer ..... Wirkliche Nummer des Bondes
  %  bond_nro ... Zeile in der Bondliste
  %  nro_a ...... Wirkliche Nummer des VON-Knotens
  %  nro_z ...... Wirkliche Nummer des NACH-Knotens
  %  znro_a ..... Zeilennummer des VON-Knotens
  %  znro_z ..... Zeilennummer des NACH-Knotens

  redraw_flag = strcmp(in1,'redraw');
  if(redraw_flag)
    bond_nro = in2;
    znro_a = find(LPFEIL(:,bond_nro)==+1);
    znro_z = find(LPFEIL(:,bond_nro)==-1);
    kaus = LKAUS(znro_a,bond_nro);
    h_pfeil = LBONDS(bond_nro,1);
    userdata = get(h_pfeil,'userdata');
    h_nummer = userdata(3);
    old_text_pos = get(h_nummer,'position');
    h_ks = userdata(2);
    if(nargin == 4)
      if(isstr(in3))
	if(findstr(in3,'effort')==1)
	  kaus = 1;
	elseif(findstr(in3,'flow')==1)
	  kaus = -1;
	elseif(findstr(in3,'acausal')==1)
	  kaus = 0;
	else
	  disp('Error in causality input');
	  disp('''effort'',''flow'' or ''acausal'' expected');
	end
	zwi_pu = [(get(h_pfeil,'xdata'))' (get(h_pfeil,'ydata'))'];
	zwi_pu = zwi_pu(2:(size(zwi_pu,1)-2),:);
      else
	zwi_pu = in3;
      end
    else  % nargin==3
      zwi_pu = [(get(h_pfeil,'xdata'))' (get(h_pfeil,'ydata'))'];
      zwi_pu = zwi_pu(2:(size(zwi_pu,1)-2),:);
    end  %if(nargin==4)
  else  % dh. if(~redraw)
    nummer = in1;
    nro_a = in2;
    nro_z = in3;
    znro_a = find(LELEMS2==nro_a);
    znro_z = find(LELEMS2==nro_z);
    if(nargin == 6)
      zwi_pu = in4;
      if(findstr(in5,'effort') == 1)
	kaus = 1;
      elseif(findstr(in5,'flow') == 1)
	kaus = -1;
      elseif(findstr(in5,'acausal') == 1)
	kaus = 0;
      else
	disp('Error in causality input');
	disp('''effort'',''flow'' or ''acausal'' expected');
      end
    elseif(nargin == 5)
      if(isstr(in4))
	zwi_pu = [];
	if(findstr(in4,'effort') == 1)
	  kaus = 1;
	elseif(findstr(in4,'flow') == 1)
	  kaus = -1;
	elseif(findstr(in4,'acausal') == 1)
	  kaus = 0;
	else
	  disp('Error in causality input');
	  disp('''effort'',''flow'' or ''acausal'' expected');
	end
      else
	zwi_pu = in4;
	kaus = 0;
      end
    else % dh. nargin==4
      zwi_pu = [];
      kaus = 0;
    end %if(nargin==...)
  end  %if(redraw)

  pf_f = 1.4; 	    % Pfeil-Faktor
  ks_f = 0.7; 	    % Kausalit"atsstrich-Faktor
  bond_col = [1 1 1]; % Bond_Color, normal
  num_col = [1 1 1]; % Farbe f"ur der Bonde Nummern
  ks_col = [1 1 1]; % Kausalit"atsstrich-Color

  pos_a = get(LELEMS(znro_a,1),'position');
  pos_a = pos_a(1:2);

  pos_z = get(LELEMS(znro_z,1),'position');
  pos_z = pos_z(1:2);

  if(zwi_pu == [])
    b = pos_z;
  else
    b = zwi_pu(1,:);
  end

  a = pos_a + LIN_ABST*kalibond(F_normiere,b-pos_a);

  if(zwi_pu == [])
    c = a;
  else
    c = zwi_pu(size(zwi_pu,1),:);
  end

  z = pos_z + LIN_ABST*kalibond(F_normiere,c-pos_z);

  cz_rot = (180/pi) * atan2(z(2)-c(2),z(1)-c(1));
  if((cz_rot > -90)&(cz_rot <= 90))
    alpha = -pi/6;
    text_rot = cz_rot;
  else
    alpha = pi/6;
    text_rot = cz_rot + 180;
  end
  rot = [cos(alpha) -sin(alpha); sin(alpha) cos(alpha)];
  % Matrix zum Rotieren

  zz = z + pf_f*(rot*(kalibond(F_normiere,c-z))')';

  pfeil = [a; zwi_pu; z; zz];
  x = pfeil(:,1);
  y = pfeil(:,2);
  if(redraw_flag)
    set(h_pfeil,'xdata',x', ...
	'ydata',y');
  else
    h_pfeil = line(x,y,'color',bond_col, ...
	'buttondownfcn',['kalibond(',int2str(F_bond_clicked),');']);
  end %if(redraw_flag)

  if(~redraw_flag)
    bond_nro = size(LBONDS,1) + 1;
  end
  
  text_pos = (c+z)/2;
  if(redraw_flag)
    set(h_nummer,'position',[text_pos old_text_pos(3)], ...
	'rotation',text_rot); 
  else
    h_nummer = text(text_pos(1),text_pos(2),0,  ...
	int2str(nummer), ...
	'rotation', text_rot, ...
	'color',num_col, ...
	'horizontalalignment','center', ...
	'verticalalignment','bottom', ...
	'buttondownfcn',['kalibond(',int2str(F_bond_clicked),');']);
  end

  ks_new = 0;
  if(kaus == 1)     % effort
    ks = ks_f*([0 -1;1 0]*(kalibond(F_normiere,c-z))')';
    ks1 = z + ks;
    ks2 = z - ks;
    if((redraw_flag)&(h_ks~=0))
      set(h_ks,'xdata',[ks1(1) ks2(1)], ...
	  'ydata',[ks1(2) ks2(2)]);
    else
      h_ks = line([ks1(1);ks2(1)],[ks1(2);ks2(2)], ...
	  'color',ks_col);
      ks_new = 1;
    end
  elseif(kaus == -1) % flow
    ks = ks_f*([0 -1;1 0]*(kalibond(F_normiere,a-b))')';
    ks1 = a + ks;
    ks2 = a - ks;
    if((redraw_flag)&(h_ks~=0))
      set(h_ks,'xdata',[ks1(1) ks2(1)], ...
	  'ydata',[ks1(2) ks2(2)]);
    else
      h_ks = line([ks1(1);ks2(1)],[ks1(2);ks2(2)], ...
	  'color',ks_col);
      ks_new = 1;
    end
  else 		    %(kaus == 0)
    if(h_ks ~= 0)
      delete(h_ks);
      ks_new = 1;
    end
    h_ks = 0;
  end 		    %if(kaus==...)

  if(redraw_flag)
    if(ks_new)
      userdata(2) = h_ks;
      set(userdata(1),'userdata',userdata);
      if(h_ks)
	set(userdata(2),'userdata',userdata);
      end
      set(userdata(3),'userdata',userdata);
    end
  else 		    % dh if(~redraw_flag)
    userdata(1) = h_pfeil;
    userdata(2) = h_ks;
    userdata(3) = h_nummer;
    set(userdata(1),'userdata',userdata);
    if(h_ks)
      set(userdata(2),'userdata',userdata);
    end
    set(userdata(3),'userdata',userdata);
    LBONDS(bond_nro,1) = h_pfeil;
    LBONDS2(bond_nro,1) = nummer;
    if(~size(LPFEIL,1))
      LPFEIL = zeros(size(LELEMS,1),size(LBONDS,1));
    end
    LPFEIL(znro_a,bond_nro) = +1;
    LPFEIL(znro_z,bond_nro) = -1;
  end
  if(~size(LKAUS,1))
    LKAUS = zeros(size(LELEMS,1),size(LBONDS,1));
  end
  LKAUS(znro_a,bond_nro) = kaus * (+1);
  LKAUS(znro_z,bond_nro) = kaus * (-1);


elseif(action == F_elem)
  %%%%%%%%%%%%%%%%%%%%%%%
  % Zeichne das Element %
  %%%%%%%%%%%%%%%%%%%%%%%
  %
  %  Aufruf: kalibond('elem',nro,pos,'typ',par)
  %        | kalibond('elem',nro,pos,'typ')
  %        | kalibond('elem',nro,pos)
  %        | kalibond('elem','redraw1',znro,pos)
  %        | kalibond('elem','redraw2',znro)
  %
  %  Funktion:
  %    - normal:
  %      -- Zeichne das Element
  %      -- Trage Nummer, Handle, Typ und Parameter als letzte (=neue)
  %         Zeile in die Listen LELEMS bzw. LELEMS2 ein
  %    - redraw1: Setze es an die neue Position
  %    - redraw2: Positioniere den Parameter neu
  % 
  %  nro ............ Wirkliche Nummer des Elementes
  %  znro ........... Zeilennummer in der Element-Liste
  %  pos == [x y] ... Position des Elementes
  %

  redraw1_flag = strcmp(in1,'redraw1');
  redraw2_flag = strcmp(in1,'redraw2');
  
  if(redraw1_flag)
    znro = in2;
    pos = in3;
    set(LELEMS(znro,1),'Position',[pos 0]);
    
  elseif(redraw2_flag)
    znro = in2;
    pos = get(LELEMS(znro,1),'Position');
    pos = pos(1:2);
    typ = LELEMS(znro,2);
    parameter = LELEMS(znro,3);
    userdata = get(LELEMS(znro,1),'UserData');
    if(parameter)
      if(size(LPFEIL,2))
	bonds = find(LPFEIL(znro,:));
	anz_bonds = size(bonds,2);
      else
	anz_bonds = 0;
      end
      if(anz_bonds==0);
	winkel = 180;
      elseif(anz_bonds==1)
	richtung = LPFEIL(znro,bonds);
	h_pfeil = LBONDS(bonds,1);
	pfeil = [(get(h_pfeil,'XData'))' (get(h_pfeil,'YData'))'];
	if(richtung==(+1))
	  punkt = pfeil(2,:);
	else
	  punkt = pfeil(size(pfeil,1)-2,:);
	end
	punkt = punkt - pos;
	winkel = (atan2(punkt(2),punkt(1))+pi)*(180/pi);
	
      elseif(anz_bonds==2)
	richtung1 = LPFEIL(znro,bonds(1));
	richtung2 = LPFEIL(znro,bonds(2));
	h_pfeil1 = LBONDS(bonds(1),1);
	h_pfeil2 = LBONDS(bonds(2),1);
	pfeil1 = [(get(h_pfeil1,'XData'))' (get(h_pfeil1,'YData'))'];
	pfeil2 = [(get(h_pfeil2,'XData'))' (get(h_pfeil2,'YData'))'];
	if(richtung1==(+1))
	  punkt1 = pfeil1(2,:);
	else
	  punkt1 = pfeil1(size(pfeil1,1)-2,:);
	end
	if(richtung2==(+1))
	  punkt2 = pfeil2(2,:);
	else
	  punkt2 = pfeil2(size(pfeil2,1)-2,:);
	end
	punkt1 = punkt1 - pos;
	punkt2 = punkt2 - pos;
	winkel1 = (atan2(punkt1(2),punkt1(1))+pi)*(180/pi);
	winkel2 = (atan2(punkt2(2),punkt2(1))+pi)*(180/pi);
	if(winkel1>winkel2)
	  tmp = winkel1;
	  winkel1 = winkel2;
	  winkel2 = tmp;
	end
	winkel = (winkel1 + winkel2) / 2;
	if(winkel2-winkel1>180)
	  winkel = winkel - 180;
	  if(winkel<0)
	    winkel = winkel + 360;
	  end
	end
      else
	winkel = 180;
      end

      if( (winkel<=45) | (winkel>=315) )
	position = 0; % rechts
	hori = 'left';
	vert = 'middle';
      elseif( (winkel>=45) & (winkel<=135) )
	position = 1; % oben
	hori = 'center';
	vert = 'bottom';
      elseif( (winkel>=135) & (winkel<=225) )
	position = 2; % links
	hori = 'right';
	vert = 'middle';	
      elseif( (winkel>=225) & (winkel<=315) )
	position = 3; % unten
	hori = 'center';
	vert = 'top';
      end
      pos_winkel = position*pi/2;
      pos_p1 = [LIN_ABST LIN_ABST/4];
      pos_p2 = [LIN_ABST -LIN_ABST/4];
      pos_par = [1.5*LIN_ABST 0];
      rotmatrix = [cos(pos_winkel) -sin(pos_winkel); ...
	  sin(pos_winkel) cos(pos_winkel)];
      pos_p1 = pos+(rotmatrix * pos_p1')';
      pos_p2 = pos+(rotmatrix * pos_p2')';
      pos_par = pos+(rotmatrix * pos_par')';
      if(userdata(4))
	set(userdata(2),'Xdata',pos_p1(1),'Ydata',pos_p1(2));
	set(userdata(3),'Xdata',pos_p2(1),'Ydata',pos_p2(2));
	set(userdata(4),'Position',[pos_par 0], ...
	    'HorizontalAlignment',hori, ...
	    'VerticalAlignment',vert, ...
	    'String',num2str(parameter));
      else
	font_size = get(userdata(1),'FontSize')*11/12;
	colour = get(userdata(1),'Color');
	userdata(2) = line(pos_p1(1),pos_p1(2),0);
	userdata(3) = line(pos_p2(1),pos_p2(2),0);
	userdata(4) = text(pos_par(1),pos_par(2),0,num2str(parameter));
	for i=2:3
	  set(userdata(i),'LineStyle','.', ...
	      'MarkerSize',10);
	end
	for i=2:4
	  set(userdata(i),'Color',colour,'UserData',userdata);
	end
	set(userdata(4),'HorizontalAlignment',hori, ...
	    'VerticalAlignment',vert, ...
	    'FontSize',font_size);
	set(userdata(1),'UserData',userdata);
      end
    else 	    % d. h. parameter == 0
      if(userdata(4))
	for i=2:4
	  delete(userdata(i));
	  userdata(i) = 0;
	end
	set(userdata(1),'UserData',userdata);
      end
    end
    
  else 		    % d. h. kein redraw 
    nro = in1;
    pos = in2;
  
    if(nargin < 5)
      par = 0;
    else
      par = in4;
    end
    if(nargin < 4)
      typ = '?';
    else
      typ = in3;
    end
  
    if(strcmp(typ,'SE'))
      typ_nro = TYP_SE;
    elseif(strcmp(typ,'SF'))
      typ_nro = TYP_SF;
    elseif(strcmp(typ,'I'))
      typ_nro = TYP_I;
    elseif(strcmp(typ,'C'))
      typ_nro = TYP_C;
    elseif(strcmp(typ,'R'))
      typ_nro = TYP_R;
    elseif(strcmp(typ,'1'))
      typ_nro = TYP_1;
    elseif(strcmp(typ,'0'))
      typ_nro = TYP_0;
    elseif(strcmp(typ,'TF'))
      typ_nro = TYP_TF;
    elseif(strcmp(typ,'GY'))
      typ_nro = TYP_GY;
    elseif(strcmp(typ,'?'))
      typ_nro = TYP_XX;
    end

    % znro ... n"achste freie Zeile in der Elementliste
    znro = size(LELEMS,1) + 1;

    if(size(LELEMS,1))
      nummer = size(find(LELEMS(:,2)==typ_nro),1) + 1;
    else
      nummer = 1;
    end

    if((typ_nro==TYP_0)|(typ_nro==TYP_1)|(typ_nro==TYP_XX))
      h_neu = text(pos(1),pos(2),0, ...
	  typ);
    else
      h_neu = text(pos(1),pos(2),0, ...
	  [typ int2str(nummer)]);
    end
    userdata = [h_neu 0 0 0];
    set(h_neu,'verticalalignment','middle', ...
	'horizontalalignment','center', ...
	'buttondownfcn',['kalibond(',int2str(F_element_clicked),');'], ...
	'Userdata',userdata);
  
    LELEMS(znro,1) = h_neu;
    LELEMS(znro,2) = typ_nro;
    LELEMS(znro,3) = par;
    LELEMS2(znro,1) = nro;
    
    % Jetzt LKAUS und LPFEIL um ein Element aufblasen

    if(size(LKAUS,2))
      LKAUS(znro,:) = zeros(1,size(LKAUS,2));
      LPFEIL(znro,:) = zeros(1,size(LPFEIL,2));
    else
      anz_bonds = size(LBONDS,1);
      if(anz_bonds)
	LKAUS = zeros(1,anz_bonds);
	LPFEIL = zeros(1,anz_bonds);
      end
    end
    
  end 		    % kein redraw

elseif(action == F_matrizen)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Lade der Matrizen Namen %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == String: A
  %  in2 == String: B
  %  in3 == String: C
  %  in4 == String: D
  %  in5 == String: E
  %  in6 == String: F
  %

  MATR_NAM = [];
  MATR_NAM = in1;
  MATR_NAM = str2mat(MATR_NAM, in2);
  MATR_NAM = str2mat(MATR_NAM, in3);
  MATR_NAM = str2mat(MATR_NAM, in4);
  MATR_NAM = str2mat(MATR_NAM, in5);
  MATR_NAM = str2mat(MATR_NAM, in6);
  MATR_OUT = ['['];
  for i=1:6
    MATR_OUT = [MATR_OUT deblank(MATR_NAM(i,:)) ','];
  end
  MATR_OUT = MATR_OUT(:,1:size(MATR_OUT,2)-1);
  MATR_OUT = [MATR_OUT ']'];
  set(H_M_RECHNE, ...
      'callback',[MATR_OUT ' = kalibond(',int2str(F_rechne1),')']);
  
  
elseif(action == F_outvec)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Lade den Ausgangsvektor %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == String: Ausgangsvektor (Zeilenvektor, ohne die eckigen Klammern)
  %

  OUT_VEC = in1;
  
  
elseif(action==F_nelem)
  %%%%%%%%%%%%%%%%%
  % Neues Element %
  %%%%%%%%%%%%%%%%%
  %
  %  in1 == pos == [x y] ... Position des neuen Elementes
  %
  %  optional:
  %  in2 == String: Typ
  %

  pos = in1;
  
  % suche die n"achste freie wirkliche Elementnummer
  
  gefunden = 0;
  i = 1;
  
  while(~gefunden)
    if(any(LELEMS2==i)) % nummer i schon vergeben
      i = i + 1;
    else
      nummer = i;
      gefunden = 1;
    end
  end
  
  % zeichne das Element
  if(nargin<3)
    kalibond(F_elem,nummer,pos);
  else
    kalibond(F_elem,nummer,pos,in2);
  end
  
elseif(action == F_nbond)
  %%%%%%%%%%%%%%
  % Neuer Bond %
  %%%%%%%%%%%%%%
  %
  %  in1 == nro_a .... Wirkliche Nummer des VON-Elementes
  %  in2 == nro_z .... Wirkliche Nummer des NACH-Elementes
  %  in3 == zwi_pu ... Positionen der Zwischenpunkte
  %

  nro_a = in1;
  nro_z = in2;
  zwi_pu = in3;

  % suche die n"achste freie wirkliche Bondnummer
  
  gefunden = 0;
  i = 1;
  
  while(~gefunden)
    if(any(LBONDS2==i)) % nummer i schon vergeben
      i = i + 1;
    else
      nummer = i;
      gefunden = 1;
    end
  end
  
  % zeichne den Bond
  kalibond(F_bond,nummer,nro_a,nro_z,zwi_pu);
  znro_a = find(LELEMS2==nro_a);
  znro_z = find(LELEMS2==nro_z);
  kalibond(F_elem,'redraw2',znro_a);
  kalibond(F_elem,'redraw2',znro_z);
  kalibond(F_modified_on,'struktur');

  
elseif(action == F_elem_num)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Elemente neu durchnumerieren %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  % in1 == typ_nro ... Typ der neu zu numerierenden Elemente
  %
  
  typ_nro = in1;
  
  if((typ_nro==TYP_1)|(typ_nro==TYP_0)|(typ_nro==TYP_XX))
    % Diese Typen werden nicht numeriert
    return;
  end
  if(typ_nro==TYP_SE)
    typ_str = 'SE';
  elseif(typ_nro==TYP_SF)
    typ_str = 'SF';
  elseif(typ_nro==TYP_C)
    typ_str = 'C';
  elseif(typ_nro==TYP_I)
    typ_str = 'I';
  elseif(typ_nro==TYP_R)
    typ_str = 'R';
  elseif(typ_nro==TYP_TF)
    typ_str = 'TF';
  elseif(typ_str==TYP_GY)
    typ_str = 'GY';
  end
  if(size(LELEMS,1))
    [zeilen,spalten] = find(LELEMS(:,2)==typ_nro);
  else
    zeilen = [];
  end
  anzahl = size(zeilen,1);
  for i=1:anzahl
    set(LELEMS(zeilen(i),1),'String',[typ_str,int2str(i)]);
  end
  
  
elseif(action == F_move_zwipu)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % WindowButtonMotionFcn: Zwischenpunkt moven %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  pos = get(gca,'CurrentPoint');
  pos = round(pos(1,1:2));
  xdata = get(DRAWTMP,'xdata');
  xdata(2) = pos(1);
  ydata = get(DRAWTMP,'ydata');
  ydata(2) = pos(2);
  set(DRAWTMP,'XData',xdata,'YData',ydata);
  

elseif(action == F_moved_zwipu)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % WindowButtonUpFcn: Zwischenpunkt moven ist fertig %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  pos = get(gca,'CurrentPoint');
  kalibond(F_message_off);
  pos = round(pos(1,1:2));
  pfeil = LBONDS(DRAWTMP2(1),1);
  xdata = get(pfeil,'XData');
  ydata = get(pfeil,'YData');
  linie = [xdata' ydata'];
  zwi_pu = linie(2:(size(linie,1)-2),:);
  zwi_pu(DRAWTMP2(2),:) = pos;
  kalibond(F_bond,'redraw',DRAWTMP2(1),zwi_pu);
  znro_elems = find(LPFEIL(:,DRAWTMP2(1)));
  kalibond(F_elem,'redraw2',znro_elems(1));
  kalibond(F_elem,'redraw2',znro_elems(2));
  delete(DRAWTMP);
  DRAWTMP = [];
  DRAWTMP2 = [];
  set(gcf,'WindowButtonMotionFcn','');
  set(gcf,'WindowButtonUpFcn','');
  
elseif(action == F_move_elem)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % WindowButtonMotionFcn: Element moven %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  pos = get(gca,'CurrentPoint');
  pos = round(pos(1,1:2));
  anz_bonds = size(DRAWTMP,1);
  for i=1:anz_bonds
    xdata = get(DRAWTMP(i,1),'XData');
    xdata(1) = pos(1);
    ydata = get(DRAWTMP(i,1),'YData');
    ydata(1) = pos(2);
    set(DRAWTMP(i,1),'XData',xdata,'Ydata',ydata);
  end
  
  
elseif(action == F_moved_elem)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % WindowButtonUpFcn: Element moven ist fertig %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  pos = get(gca,'CurrentPoint');
  set(H_BILD,'Pointer','watch');
  drawnow;
  kalibond(F_message_off);
  pos = round(pos(1,1:2));
  kalibond(F_elem,'redraw1',DRAWTMP2(1,1),pos);
  anz_bonds = size(DRAWTMP,1);
  for i=2:anz_bonds+1
    kalibond(F_bond,'redraw',DRAWTMP2(i));
    znro_elems = find(LPFEIL(:,DRAWTMP2(i)));
    for j=1:2
      if(znro_elems(j)~=DRAWTMP2(1))
	kalibond(F_elem,'redraw2',znro_elems(j));
      end
    end
  end
  kalibond(F_elem,'redraw2',DRAWTMP2(1));
  delete(DRAWTMP);
  DRAWTMP = [];
  DRAWTMP2 = [];
  set(gcf,'WindowButtonMotionFcn','');
  set(gcf,'WindowButtonUpFcn','');
  set(H_BILD,'Pointer','arrow');
  
    
elseif(action == F_axis_clicked)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % ButtonDownFcn wenn in den leeren Raum "`geklickt"' %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if(strcmp(DRAWMODE,'bond'))
    pos = get(gca,'CurrentPoint');
    pos = pos(1,1:2);
    pos = round(pos);
    if(DRAWLEVEL==0)
      kalibond(F_nelem,pos);
      % sichere die wirkliche Elementnummer
      DRAWTMP = LELEMS2(size(LELEMS2,1));
      DRAWLEVEL = 1;
      kalibond(F_message_on,['mouse-1: Bond''s arrowhead' 13 ...
	      'mouse-3: Bond''s knee']);
    elseif(DRAWLEVEL==1)
      maus = get(gcf,'SelectionType');
      if(strcmp(maus,'normal'))
	kalibond(F_message_off);
	kalibond(F_nelem,pos);
	endpunkt = LELEMS2(size(LELEMS2,1));
	kalibond(F_nbond,DRAWTMP(1),endpunkt,DRAWTMP2);
	if(size(DRAWTMP,1)==2)
	  delete(DRAWTMP(2));
	end
	DRAWTMP = [];
	DRAWTMP2 = [];
	DRAWLEVEL = 0;
      elseif(strcmp(maus,'extend'))
	if(size(DRAWTMP,1)==2)
	  xdata = get(DRAWTMP(2),'Xdata');
	  ydata = get(DRAWTMP(2),'Ydata');
	  linie = [xdata; ydata];
	  linie = [linie pos'];
	  set(DRAWTMP(2),'Xdata',linie(1,:), ...
	      'Ydata',linie(2,:), ...
	      'Zdata',zeros(size(linie(1,:))));
	else
	  blau = [0 0 1];
	  znro = find(LELEMS2==DRAWTMP(1));
	  pos_1 = get(LELEMS(znro,1),'Position');
	  pos_1 = pos_1(1:2);
	  DRAWTMP = [DRAWTMP; ...
	      line([pos_1(1);pos(1)],[pos_1(2);pos(2)],[0;0], ...
		  'Color',blau)];
	end 
	DRAWTMP2 = [DRAWTMP2; pos];
      end
    end
  elseif( (strcmp(DRAWMODE,'SE')) ...
	| (strcmp(DRAWMODE,'SF')) ...
	| (strcmp(DRAWMODE,'C')) ...
	| (strcmp(DRAWMODE,'I')) ...
	| (strcmp(DRAWMODE,'R')) ...
	| (strcmp(DRAWMODE,'TF')) ...
	| (strcmp(DRAWMODE,'GY')) ...
	| (strcmp(DRAWMODE,'0')) ...
	| (strcmp(DRAWMODE,'1')) )
    pos = get(gca,'CurrentPoint');
    pos = pos(1,1:2);
    pos = round(pos);
    kalibond(F_nelem,pos,DRAWMODE);
    kalibond(F_modified_on,'struktur');
  end
	
  % Bei allen anderen DRAWMODEs ist 'axis_clicked' zu ignorieren
  
elseif(action == F_bond_clicked)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % ButtonDownFcn wenn Bond "`angeklickt"' %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if(strcmp(DRAWMODE,'move'))
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    pfeil = userdata(1);
    if(size(LPFEIL,1))
      bond_nro = find(LBONDS(:,1)==pfeil);
      if( (size(find(LPFEIL(:,bond_nro)==+1),1)==1) & ...
	    (size(find(LPFEIL(:,bond_nro)==-1),1)==1) )
	xdata = get(pfeil,'XData');
	ydata = get(pfeil,'YData');
	linie = [xdata' ydata'];
	zwi_pu = linie(2:(size(linie,1)-2),:);
	anz_zwi_pu = size(zwi_pu,1);
	if(anz_zwi_pu>0) % es gibt Zwischenpunkte
	  kalibond(F_message_on,'drag-mouse-1: move to');
	  pos = get(gca,'CurrentPoint');
	  pos = pos(1,1:2);
	  abstand = inf;
	  nro_zp = 0;
	  for i=1:anz_zwi_pu
	    x_abst = pos(1) - zwi_pu(i,1);
	    y_abst = pos(2) - zwi_pu(i,2);
	    temp_abst = x_abst^2 + y_abst^2;
	    if(temp_abst < abstand)
	      abstand = temp_abst;
	      nro_zp = i;
	    end
	  end
	  if(nro_zp==1)
	    anfang = get(LELEMS(find(LPFEIL(:,bond_nro)==+1),1),'Position');
	    anfang = anfang(1:2);
	  else
	    anfang = zwi_pu(nro_zp-1,:);
	  end
	  if(nro_zp==anz_zwi_pu)
	    ende = get(LELEMS(find(LPFEIL(:,bond_nro)==-1),1),'Position');
	    ende = ende(1:2);
	  else
	    ende = zwi_pu(nro_zp+1,:);
	  end
	  neu_pos = round(pos);
	  blau = [0 0 1];
	  DRAWTMP = line([anfang(1);neu_pos(1);ende(1)], ...
	      [anfang(2);neu_pos(2);ende(2)], ...
	      [0;0;0], ...
	      'color',blau);
	  DRAWTMP2 = [bond_nro nro_zp];
	  set(gcf,'WindowButtonMotionFcn', ...
	      ['kalibond(',int2str(F_move_zwipu),');']);
	  set(gcf,'WindowButtonUpFcn', ...
	      ['kalibond(',int2str(F_moved_zwipu),');']);
	end 	    %if(anz_zwi_pu>0)
      end
    end
        
  elseif(strcmp(DRAWMODE,'del'))
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    pfeil = userdata(1);
    bond_nro = find(LBONDS(:,1)==pfeil);
    if(size(LPFEIL,1))
      znro_elems = find(LPFEIL(:,bond_nro));
      anz_elems = size(znro_elems,2);
    else 	    % dh. keine Elemente mehr vorhanden
      anz_elems = 0;
    end
    LBONDS(bond_nro,:) = [];
    LBONDS2(bond_nro,:) = [];
    if(size(LPFEIL,2))
      LPFEIL(:,bond_nro) = [];
    end
    if(size(LKAUS,2))
      LKAUS(:,bond_nro) = [];
    end
    delete(userdata(1));
    if(userdata(2))
      delete(userdata(2));
    end
    delete(userdata(3));
    for i=1:anz_elems
      kalibond(F_elem,'redraw2',znro_elems(i));
    end
    kalibond(F_modified_on,'struktur');
  
  elseif(strcmp(DRAWMODE,'causa'))
    % Handle auf des Bondes Pfeil
    pfeil = get(get(gcf,'CurrentObject'),'UserData');
    pfeil = pfeil(1);
    if(size(LPFEIL,1))
      bond_nro = find(LBONDS(:,1)==pfeil);
      if( (size(find(LPFEIL(:,bond_nro)==+1),1)==1) & ...
	    (size(find(LPFEIL(:,bond_nro)==-1),1)==1) )
	if(DRAWLEVEL==0)
	  kalibond(F_message_on,'mouse-1: Where to put the causal stroke')
	  % sichere den Handle auf des Bondes Pfeil
	  DRAWTMP = pfeil;
	  DRAWLEVEL = 1;
	elseif(DRAWLEVEL==1)
	  if(DRAWTMP==pfeil) % derselbe Bond
	    kalibond(F_message_off);
	    kalibond(F_bond,'redraw',bond_nro,'acausal');
	    DRAWTMP = [];
	    DRAWLEVEL = 0; 
	    kalibond(F_modified_on,'kausa');
	  else 	    % ein anderer Bond
	    % ignorieren
	  end
	end
      end
    end
  end


elseif(action == F_element_clicked)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % ButtonDownFcn wenn Element "`angeklickt"' %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if(strcmp(DRAWMODE,'bond'))
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    h_element = userdata(1);
    znummer = find(LELEMS(:,1)==h_element);
    nummer = LELEMS2(znummer,1);
    if(DRAWLEVEL==0)
      kalibond(F_message_on,['mouse-1: Bond''s arrowhead' 13 ...
	      'mouse-3: Bond''s knee']);
      DRAWTMP = nummer;
      DRAWLEVEL = 1;
    elseif(DRAWLEVEL==1)
      if(DRAWTMP(1)~=nummer)
	kalibond(F_message_off);
	kalibond(F_nbond,DRAWTMP(1),nummer,DRAWTMP2);
	if(size(DRAWTMP,1)==2)
	  delete(DRAWTMP(2));
	end
	DRAWTMP = [];
	DRAWTMP2 = [];
	DRAWLEVEL = 0;
      end
    end
    
  elseif( (strcmp(DRAWMODE,'SE')) ...
	| (strcmp(DRAWMODE,'SF')) ...
	| (strcmp(DRAWMODE,'C')) ...
	| (strcmp(DRAWMODE,'I')) ...
	| (strcmp(DRAWMODE,'R')) ...
	| (strcmp(DRAWMODE,'0')) ...
	| (strcmp(DRAWMODE,'1')) ...
	| (strcmp(DRAWMODE,'TF')) ...
	| (strcmp(DRAWMODE,'GY')) )
    typ = DRAWMODE;
    if(strcmp(typ,'SE'))
      typ_nro = TYP_SE;
    elseif(strcmp(typ,'SF'))
      typ_nro = TYP_SF;
    elseif(strcmp(typ,'C'))
      typ_nro = TYP_C;
    elseif(strcmp(typ,'I'))
      typ_nro = TYP_I;
    elseif(strcmp(typ,'R'))
      typ_nro = TYP_R;
    elseif(strcmp(typ,'TF'))
      typ_nro = TYP_TF;
    elseif(strcmp(typ,'GY'))
      typ_nro = TYP_GY;
    elseif(strcmp(typ,'0'))
      typ_nro = TYP_0;
    elseif(strcmp(typ,'1'))
      typ_nro = TYP_1;
    elseif(strcmp(typ,'?'))
      typ_nro = TYP_XX;
    end
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    h_element = userdata(1);
    znummer = find(LELEMS(:,1)==h_element);
    nummer = LELEMS2(znummer,1);
    oldtyp = LELEMS(znummer,2);
    if(oldtyp==typ_nro)
    else
      if((typ_nro==TYP_0)|(typ_nro==TYP_1)|(typ_nro==TYP_XX))
	set(h_element,'String',typ);
	% In den anderen F"allen "ubernimmt die 
	% Numerierungsroutine das setzen des Strings
      end
      LELEMS(znummer,2) = typ_nro;
      kalibond(F_elem_num,typ_nro);
      kalibond(F_elem_num,oldtyp);
      kalibond(F_modified_on,'struktur');
    end
    
  elseif(strcmp(DRAWMODE,'move'))
    kalibond(F_message_on,'drag-mouse-1: move to');
    blau = [0 0 1];
    DRAWTMP = [];
    DRAWTMP2 = [];
    %    $$$$$$$$$$$$$$$$$$
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    element = userdata(1);
    pos = get(element,'Position');
    pos = pos(1,1:2);
    elem_nro = find(LELEMS(:,1)==element);
    DRAWTMP2 = elem_nro;
    if(size(LPFEIL,2))
      bonds = find(LPFEIL(elem_nro,:));
      anz_bonds = size(bonds,2);
    else
      anz_bonds = 0;
    end
    for i=1:anz_bonds
      xdata = get(LBONDS(bonds(i),1),'XData');
      ydata = get(LBONDS(bonds(i),1),'YData');
      linie = [xdata' ydata'];
      zwi_pu = linie(2:(size(linie,1)-2),:);
      anz_zwi_pu = size(zwi_pu,1);
      if(anz_zwi_pu > 0)
	if(LPFEIL(elem_nro,bonds(i)) == (+1))
	  ende = zwi_pu(1,:);
	else
	  ende = zwi_pu(size(zwi_pu,1),:);
	end
      else
	if(LPFEIL(elem_nro,bonds(i)) == (+1))
	  anderes = find(LPFEIL(:,bonds(i))==(-1));
	else
	  anderes = find(LPFEIL(:,bonds(i))==(+1));
	end
	ende = get(LELEMS(anderes,1),'Position');
	ende = ende(1,1:2);
      end
      DRAWTMP = [DRAWTMP; ...
	  line([pos(1);ende(1)],[pos(2);ende(2)],[0;0], ...
	      'Color',blau)];
      DRAWTMP2 = [DRAWTMP2; bonds(i)];
    end
    set(gcf,'WindowButtonMotionFcn', ...
	['kalibond(',int2str(F_move_elem),');']);
    set(gcf,'WindowButtonUpFcn', ...
	['kalibond(',int2str(F_moved_elem),');']);
    
  elseif(strcmp(DRAWMODE,'par'))
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    h_element = userdata(1);
    znummer = find(LELEMS(:,1)==h_element);
    nummer = LELEMS2(znummer);
    typ_str = get(h_element,'String');
    if( (findstr(typ_str,'0')==1) ...
	  | (findstr(typ_str,'1')==1) ...
	  | (findstr(typ_str,'S')==1) )
    else
      if(findstr(typ_str,'R')==1)
	elem_str = 'R ';
      elseif(findstr(typ_str,'C')==1)
	elem_str = 'C ';
      elseif(findstr(typ_str,'I')==1)
	elem_str = 'I ';
      elseif(findstr(typ_str,'TF')==1)
	elem_str = 'n ';
      elseif(findstr(typ_str,'GY')==1)
	elem_str = 'r ';
      else
      end
      elem_str = [elem_str,'='];
      kalibond(F_message_on,['element''s ' typ_str ' parameter']);
      current_par = LELEMS(znummer,3);
      par_str = sprintf('%.10G',current_par);
      set(H_EDIT(1),'visible','on', ...
	  'string',elem_str);
      set(H_EDIT(2),'visible','on', ...
	  'string',par_str, ...
	  'callback', ...
	  ['kalibond(',int2str(F_par_cb),',',int2str(znummer),');']);
    end
    
  elseif(strcmp(DRAWMODE,'del'))
    userdata = get(get(gcf,'CurrentObject'),'UserData');
    h_element = userdata(1);
    znummer = find(LELEMS(:,1)==h_element);
    typ_nro = LELEMS(znummer,2);
    LELEMS(znummer,:) = [];
    LELEMS2(znummer,:) = [];
    if(LPFEIL~=[])
      LPFEIL(znummer,:) = [];
    end
    if(LKAUS~=[])
      LKAUS(znummer,:) = [];
    end
    delete(userdata(1));
    if(userdata(4))
      delete(userdata(2:4));
    end
    kalibond(F_elem_num,typ_nro);
    kalibond(F_modified_on,'struktur');
    
  elseif(strcmp(DRAWMODE,'causa'))
    if(DRAWLEVEL==0)
    elseif(DRAWLEVEL==1)
      userdata = get(get(gcf,'CurrentObject'),'UserData');
      h_element = userdata(1);
      znummer = find(LELEMS(:,1)==h_element);
      znro_bond = find(LBONDS(:,1)==DRAWTMP);
      if(LPFEIL(znummer,znro_bond)==+1)  % A |-->
	kalibond(F_message_off);
	kalibond(F_bond,'redraw',znro_bond,'flow');
	LKAUS(znummer,znro_bond) = -1;
	anderes = find(LPFEIL(:,znro_bond)==-1);
	LKAUS(anderes,znro_bond) = +1;
	DRAWTMP = [];
	DRAWLEVEL = 0;
	kalibond(F_modified_on,'kausa');
      elseif(LPFEIL(znummer,znro_bond)==-1)  % A |<--
	kalibond(F_message_off);
	kalibond(F_bond,'redraw',znro_bond,'effort');
	LKAUS(znummer,znro_bond) = -1;
	anderes = find(LPFEIL(:,znro_bond)==+1);
	LKAUS(anderes,znro_bond) = +1;
	DRAWTMP = [];
	DRAWLEVEL = 0;
	kalibond(F_modified_on,'kausa');
      else
	% geh"ort nicht zum Bond: ignorieren
      end
    end
  end
  
  
elseif(action == F_zoom_in)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Bildschirmauschnitt zoomen: gr"o"ser %
  % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  kalibond(F_message_on,['ZOOM: mouse-1: first corner' 13 ...
	  'drag-mouse-1: opposite corner']);
  set(gcf,'pointer','crosshair');
  waitforbuttonpress;
  xya = get(gcf,'currentpoint');
  figpos = get(gcf,'position');
  axpos = get(gca,'position');
  axxlim = get(gca,'xlim');
  axylim = get(gca,'ylim');
  rbbox([xya 0 0],xya);
  xyb = get(0,'pointerlocation');
  kalibond(F_message_off);
  set(gcf,'pointer','arrow');
  xa = (((xya(1)/figpos(3))-axpos(1))*((axxlim(2)-axxlim(1))/axpos(3))) ...
      + axxlim(1);
  xb = ((((xyb(1)-figpos(1))/figpos(3))-axpos(1)) ...
      *((axxlim(2)-axxlim(1))/axpos(3))) + axxlim(1);
  ya = (((xya(2)/figpos(4))-axpos(2))*((axylim(2)-axylim(1))/axpos(4))) ...
      + axylim(1);
  yb = ((((xyb(2)-figpos(2))/figpos(4))-axpos(2)) ...
      *((axylim(2)-axylim(1))/axpos(4))) + axylim(1);
  if(xa<xb)
    xx = [xa xb];
  else
    xx = [xb xa];
  end
  if(ya<yb);
    yy = [ya yb];
  else
    yy = [yb ya];
  end
  axis([xx yy]);
  ZOOM_HIST = [axxlim axylim; ZOOM_HIST];


elseif(action == F_zoom_out)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Bildschirmauschnitt zoomen: kleiner %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  faktor = 0.5;
  if(ZOOM_HIST~=[])
    axis(ZOOM_HIST(1,:));
    ZOOM_HIST(1,:) = [];
  else
    a = axis;
    breite = a(2) - a(1);
    hoehe = a(4) - a(3);
    dx = breite*(1-faktor)/(2*faktor);
    dy = hoehe*(1-faktor)/(2*faktor);
    a = a + [-dx dx -dy dy];
    axis(a);
  end
  
  
elseif(action == F_zoom_max)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Bildschirmauschnitt zoomen: genau passend %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  axis('auto');
  achse = axis;
  achse = achse + 2*[-LIN_ABST LIN_ABST -LIN_ABST LIN_ABST];
  axis(achse);
  ZOOM_HIST = [];


elseif(action == F_normiere)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Normiere einen 2D-Zeilenvektor %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == x .... Zeilenvektor
  %  
  %  out1 == n ... Zeilenvektor mit dem Betrag==1

  x = in1;

  n = x / (sqrt(x(1)^2+x(2)^2));

  out1 = n;


elseif(action == F_save1)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Edit: Speichere den Bondgraphen %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if(FILENAME==0)
    kalibond(F_save_as);
  else
    kalibond(F_save2);
  end


elseif(action == F_save_as)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Edit: Speichere den Bond-Graphen (mit Namensabfrage) %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  [filename,pathname] = uiputfile('*.007','Save');

  if(filename~=0)
    FILENAME = filename;
    PATHNAME = pathname;
    set(H_BILD,'name',[BILD_NAME PATHNAME FILENAME]);
    drawnow;
    kalibond(F_save2);
  end


elseif(action == F_save2)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Die eigentliche Speicher-Routine %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  set(H_BILD,'pointer','watch');
  drawnow;

  fid = fopen([PATHNAME FILENAME],'wt');

  zeit = fix(clock);
  datum = [date ' ' int2str(zeit(4)) ':' int2str(zeit(5))];

  fprintf(fid,'%% Output of KaliBond, %s\n\n',datum);
  
  % Jetzt die Elemente
  
  anzahl = size(LELEMS,1);
  
  for i=1:anzahl
    nummer = LELEMS2(i,1);
    pos = get(LELEMS(i,1),'Position');
    typ_nro = LELEMS(i,2);
    if(typ_nro==TYP_SE)
      typ = 'SE';
    elseif(typ_nro==TYP_SF)
      typ = 'SF';
    elseif(typ_nro==TYP_C)
      typ = 'C';
    elseif(typ_nro==TYP_I)
      typ = 'I';
    elseif(typ_nro==TYP_R)
      typ = 'R';
    elseif(typ_nro==TYP_TF)
      typ = 'TF';
    elseif(typ_nro==TYP_GY)
      typ = 'GY';
    elseif(typ_nro==TYP_0)
      typ = '0';
    elseif(typ_nro==TYP_1)
      typ = '1';
    elseif(typ_nro==TYP_XX)
      typ = '?';
    end
    par = LELEMS(i,3);
    
    fprintf(fid,'(''elem'',%i,[%i %i],''%s'',%d);\n', ...
	nummer,pos(1),pos(2),typ,par);
    
  end
  
  fprintf(fid,'\n');
  
  % Jetzt die Bonde
  
  anzahl = size(LBONDS,1);
  
  for i=1:anzahl
    nummer = LBONDS2(i,1);
    nro_a = LELEMS2(find(LPFEIL(:,i)==+1),1);
    nro_z = LELEMS2(find(LPFEIL(:,i)==-1),1);
    xs = get(LBONDS(i,1),'XData');
    ys = get(LBONDS(i,1),'YData');
    anz_pu = size(xs,2);
    zwi_pu = [];
    if(anz_pu>3)
      for j=2:anz_pu-2
	zwi_pu = [zwi_pu int2str(xs(j)) ' ' int2str(ys(j)) ';'];
      end
      zwi_pu = zwi_pu(1:size(zwi_pu,2)-1);
    end
    kaus = LKAUS(find(LPFEIL(:,i)==+1),i);
    if(kaus == 0)
      kaus_s = 'acausal';
    elseif(kaus == +1)
      kaus_s = 'effort';
    elseif(kaus == -1)
      kaus_s = 'flow';
    end
    if(zwi_pu == [])
      fprintf(fid,'(''bond'',%i,%i,%i,[],''%s'');\n', ...
	  nummer,nro_a,nro_z,kaus_s);
    else
      fprintf(fid,'(''bond'',%i,%i,%i,[%s],''%s'');\n', ...
	  nummer,nro_a,nro_z,zwi_pu,kaus_s);
    end
  end

  fprintf(fid,'\n');
  
  % Jetzt der Matrizen Namen
  
  fprintf(fid, ...
      '(''matrices'',''%s'',''%s'',''%s'',''%s'',''%s'',''%s'');\n', ...
      deblank(MATR_NAM(1,:)), ...
      deblank(MATR_NAM(2,:)), ...
      deblank(MATR_NAM(3,:)), ...
      deblank(MATR_NAM(4,:)), ...
      deblank(MATR_NAM(5,:)), ...
      deblank(MATR_NAM(6,:)));
  
  fprintf(fid,'\n');
  
  % Jetzt der Ausgangsvektor

  if(OUT_VEC==[])
    fprintf(fid,'(''outvec'','''');\n');
  else
    fprintf(fid,'(''outvec'',''%s'');\n',OUT_VEC);
  end

  if(~Z_KAUSOK)
    fprintf(fid,'\n');
    fprintf(fid, ...
	'%% WARNING: This bond-graph contains causal conflicts\n');
  end

  
  
  fclose(fid);

  set(H_BILD,'pointer','arrow');
  drawnow;

  kalibond(F_modified_off);


elseif(action == F_load1)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Edit: Lade einen Bondgraphen %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  call_back = ['kalibond(',int2str(F_load2),');'];
  kalibond(F_if_modified,call_back);


elseif(action == F_load2)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Lade einen Bond-Graphen (mit Namensabfrage) %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  [filename,pathname] = uigetfile('*.007','Load');

  if(filename~=0)
    kalibond(F_load3,pathname,filename);
  end % if(filename~=0)


elseif(action == F_load3)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Die eigentliche Laderoutine %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == pathname
  %  in2 == filename
  %  

  pathname = in1;
  filename = in2;

  set(H_BILD,'Pointer','Watch');
  drawnow;
  kalibond(F_clear2);
  FILENAME = filename;
  PATHNAME = pathname;
  set(H_BILD,'Name',[BILD_NAME PATHNAME FILENAME]);
  drawnow;
  fid = fopen([PATHNAME FILENAME]);
  while 1
    line = fgetl(fid);
    if(~isstr(line))
      break;
    end
    if( (line ~= []) & (findstr(line,'%')~=1) )
      eval(['kalibond' line]);
    end
  end
  fclose(fid);
  
  if(ZUSTAND_PRUEFE==1)
    kalibond(F_pruefe);  
  else
    zust = ZUSTAND_PRUEFE;
    ZUSTAND_PRUEFE = 1;
    kalibond(F_pruefe,1);
    ZUSTAND_PRUEFE = zust;
  end
  if(ZUSTAND_PRUEFE==3)
    kalibond(F_pruefe);
  else
    zust = ZUSTAND_PRUEFE;
    ZUSTAND_PRUEFE = 3;
    kalibond(F_pruefe,1);
    ZUSTAND_PRUEFE = zust;
  end

  anzahl = size(LELEMS,1);
  for i=1:anzahl
    kalibond(F_elem,'redraw2',i);
  end

  kalibond(F_zoom_max);
  
  set(H_BILD,'Pointer','Arrow');
  drawnow;
  kalibond(F_modified_off);
  
  set(H_M_KAUS,'enable','off');
  set(H_M_RECHNE,'enable','off');
  set(H_M_SIMUL,'enable','off');
  set(H_M_IANTW,'enable','off');
  if( (Z_SCHNITZER) & (Z_KAUSOK) )
    set(H_M_KAUS,'enable','on');
    if( (Z_KAUSVOLL) & (Z_PARAMETER) )
      set(H_M_RECHNE,'enable','on');
    end
  end


elseif(action == F_message_on)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Message auf den Bildschirm %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == aus_text ...... Auszugebender Text
  %  

  aus_text = in1;

  set(H_MESSAGE,'String',aus_text);


elseif(action == F_message_off)
  %%%%%%%%%%%%%%%%%%%%
  % Message l"oschen %
  %%%%%%%%%%%%%%%%%%%%

  set(H_MESSAGE,'String','');


elseif(action == F_clear1)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % L"osche den den Bondgraphen %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  call_back = ['kalibond(',int2str(F_clear2),');'];
  kalibond(F_if_modified,call_back);


elseif(action == F_clear2)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Eigentliche L"oschroutine %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  FILENAME = 0;
  PATHNAME = 0;
  set(H_BILD,'name',[BILD_NAME 'NoName']);
  drawnow;
  objekte = get(gca,'Children');
  delete(objekte);
  LKAUS = [];
  LPFEIL = [];
  LELEMS = [];
  LELEMS2 = [];
  LBONDS = [];
  LBONDS2 = [];
  axis([0 35 0 35]);
  kalibond(F_modified_off);
  set(H_M_KAUS,'enable','off');
  set(H_M_RECHNE,'enable','off');
  set(H_M_SIMUL,'enable','off');
  set(H_M_IANTW,'enable','off');
  Z_PARAMETER = 0;
  Z_SCHNITZER = 0;
  Z_KAUSOK = 0;
  Z_KAUSVOLL = 0;
  ZOOM_HIST = [];


elseif(action == F_del_kaus)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % L"osche alle Kausalit"atseintr"age %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  anzahl = size(LBONDS,1);
  for i=1:anzahl
    userdata = get(LBONDS(i,1),'UserData');
    if(userdata(2))
      delete(userdata(2));
      userdata(2) = 0;
      set(LBONDS(i,1),'UserData',userdata);
    end
  end
  LKAUS = zeros(size(LKAUS));
  kalibond(F_modified_on,'kausa');
  kalibond(F_pruefe);


elseif(action == F_modified_on)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Das ist zu tun, wenn Ver"anderungen aufgetreten sind %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == was ... String: Was wurde ver"andert?
  %  

  was = in1; 	    % disp(['*modified*' was '*']);
  
  MODIFIED = 1;
  set(H_M_SAVE,'enable','on');
  
  if(strcmp(was,'graphik'))
  elseif(strcmp(was,'matrizen'))
  elseif(strcmp(was,'outvec'))
  elseif(strcmp(was,'parameter'))
    set(H_M_SIMUL,'enable','off');
    kalibond(F_pruefe);
    if(ZUSTAND_PRUEFE~=1)
      kalibond(F_check_par);
    end
    if( (Z_PARAMETER) & (Z_KAUSVOLL) )
      set(H_M_RECHNE,'enable','on');
    end
  elseif(strcmp(was,'struktur'))
    set(H_M_SIMUL,'enable','off');
    set(H_M_RECHNE,'enable','off');
    set(H_M_KAUS,'enable','off');
    if(ZUSTAND_PRUEFE==1)
      kalibond(F_pruefe);
    else
      zp = ZUSTAND_PRUEFE;
      ZUSTAND_PRUEFE = 1;
      kalibond(F_pruefe,1);
      ZUSTAND_PRUEFE = zp;
    end
    if(ZUSTAND_PRUEFE==3)
      kalibond(F_pruefe);
    else
      zp = ZUSTAND_PRUEFE;
      ZUSTAND_PRUEFE = 3;
      kalibond(F_pruefe,1);
      ZUSTAND_PRUEFE = zp;
    end; 	    % Z_PARAMETER, Z_KAUSOK, Z_SCHNITZER,
    if( (Z_SCHNITZER) & (Z_KAUSOK) )
      set(H_M_KAUS,'enable','on');
    end    
    if( (Z_SCHNITZER) & (Z_KAUSVOLL) & (Z_PARAMETER) )
      set(H_M_RECHNE,'enable','on');
    end    
  elseif(strcmp(was,'kausa'))
    set(H_M_SIMUL,'enable','off');
    if(ZUSTAND_PRUEFE == 2)
      kalibond(F_pruefe);
    end
    if(ZUSTAND_PRUEFE == 3)
      kalibond(F_pruefe);
    else
      zp = ZUSTAND_PRUEFE;
      ZUSTAND_PRUEFE = 3;
      kalibond(F_pruefe,1);
      ZUSTAND_PRUEFE = zp;
    end; 	    % Z_KAUSOK, Z_KAUSVOLL,
    if( (Z_SCHNITZER) & (Z_KAUSOK) )
      set(H_M_KAUS,'enable','on');
    else
      set(H_M_KAUS,'enable','off');
    end
    if( (Z_PARAMETER) & (Z_KAUSVOLL) & (Z_SCHNITZER) )
      set(H_M_RECHNE,'enable','on');
    else
      set(H_M_RECHNE,'enable','off');
    end
  else
  end
  

elseif(action == F_modified_off)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Die Ver"anderungen sind jetzt gespeichert %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  MODIFIED = 0;
  set(H_M_SAVE,'enable','off');
  kalibond(F_pruefe);


elseif(action == F_if_modified)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Abfrage: Verwerfen oder Abbrechen %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == cb ... Was ist zu tun im Falle, da"s der
  %                angezeigte (und noch nicht gespeicherte)
  %                Bondgraph verworfen werden soll,
  %                oder wenn der angezeigte Bondgraph
  %                bereits gespeichert ist.
  %                

  cb = in1;

  if(MODIFIED)
    cb2 = ['global H_VERWERF;', ...
	    'global H_ESCAPE;', ...
	    'delete(H_VERWERF);', ...
	    'delete(H_ESCAPE);', ...
	    'clear global H_VERWERF;', ...
	    'clear global H_ESCAPE;', ...
	    'kalibond(',int2str(F_message_off),');'];  
    global H_VERWERF;
    global H_ESCAPE;
    kalibond(F_message_on, ...
	['last chages not saved:' 13 ...
	'Do you wanna abandon the changes?']);
    H_VERWERF = uicontrol('position',[0 0.8 0.3 0.1], ...
	'Units','normalized', ...
	'String','abandon', ...
	'CallBack',[cb2 cb]);
    H_ESCAPE = uicontrol('position',[0.3 0.8 0.55 0.1], ...
	'Units','normalized', ...
	'String','escape', ...
	'CallBack',[cb2]);
  else
    eval(cb);
  end


elseif(action == F_edit_on)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Schalte die Edit-Buttons ein %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  h_menu = get(gcf,'currentmenu');
  set(h_menu, ...
      'label',kalibond(F_label,'&Drawmode-off'), ...
      'CallBack',['kalibond(',int2str(F_edit_off),');']);
  buttons = get(h_menu,'Userdata');
  set(buttons,'value',0, ...
      'visible','on');
  DRAWMODE = 'edit off';
  DRAWLEVEL = 0;
  DRAWTMP = [];
  DRAWTMP2 = [];
  kalibond(F_message_off);
  
  
elseif(action == F_edit_off)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Schalte die Edit-Buttons aus %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  h_menu = get(gcf,'currentmenu');
  set(h_menu, ...
      'label',kalibond(F_label,'&Drawmode-on'), ...
      'CallBack',['kalibond(',int2str(F_edit_on),');']);
  buttons = get(h_menu,'userdata');
  set(buttons,'value',0, ...
      'visible','off');
  DRAWMODE = 'edit off';
  DRAWLEVEL = 0;
  DRAWTMP = [];
  DRAWTMP2 = [];
  kalibond(F_message_off);


elseif(action == F_button_cb)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Callback f"ur die Edit-Buttons %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  thisone = get(H_BILD,'currentobject');
  others = get(thisone,'userdata');
  set(others,'value',0);
  set(thisone,'value',1);
  DRAWMODE = deblank(get(thisone,'string'));


elseif(action == F_menu_opt)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % CallBack f"ur die Sub-Men"us "`Optionen"' %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == menu_nro ... Nro des aufrufenden Men"us
  %  
  %      == 1 ... Show Ungereimtheiten
  %      == 2 ... Show integrale Kausas
  %      == 3 ... Show kausale Widerspr"uche
  %      == 4 ... Show nichts
  %      

  menu_nro = in1;

  h_menu = get(gcf,'currentmenu');
  if(menu_nro == 1)
    h_andere = get(h_menu,'userdata');
    set(h_andere,'checked','off');
    set(h_menu,'checked','on');
    ZUSTAND_PRUEFE = 1;
    kalibond(F_pruefe);
  elseif(menu_nro == 2)
    h_andere = get(h_menu,'userdata');
    set(h_andere,'checked','off');
    set(h_menu,'checked','on');
    ZUSTAND_PRUEFE = 2;
    kalibond(F_pruefe);
  elseif(menu_nro == 3)
    h_andere = get(h_menu,'userdata');
    set(h_andere,'checked','off');
    set(h_menu,'checked','on');
    ZUSTAND_PRUEFE = 3;
    kalibond(F_pruefe);
  elseif(menu_nro == 4)
    h_andere = get(h_menu,'userdata');
    set(h_andere,'checked','off');
    set(h_menu,'checked','on');
    ZUSTAND_PRUEFE = -1;
    kalibond(F_pruefe);
    ZUSTAND_PRUEFE = 0;
  end


elseif(action == F_pruefe)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Pr"ufe den Bondgraphen und f"arbe ihn ein %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == 1 ... no color
  %  
  % Je nach dem aktuellen Wert der globalen Variable ZUSTAND_PRUEFE:
  % 
  % == -1: Pru"fe nichts und mache alles wei"s
  % 
  % == 1: Pr"ufe ob des Bondgraphen Struktur Ungereimtheiten aufweist
  %       wei"s: OK
  %       gelb : Parameter fehlt noch
  %       rot  : schwerwiegender Fehler in der Struktur, dh.:
  %              SE, SF, C, I, R mit mehr als 1 Bond
  %              0, 1 mit nur einem Bond
  %              TR, GY mit mehr als 2 Bonds
  %              --> TR/GY <-- bzw. <-- TR/GY -->
  %              Bonds mit nur einem Element
  %              
  % == 2: Zeige die Kausalit"at der Speicherelemente an
  %       gr"un: integrale Kausalit"at
  %       rot  : differentielle Kausalit"at
  %       
  % == 3: Zeige kausale Widerspr"uche an
  %       gr"un: Kausalit"at ist korrekt
  %       rot  : Widerspruch
  %       wei"s: akausal
  %       
  % default: No Operation
  % 

  yescolor = 1;
  if(nargin>1)
    if(in1==1)
      yescolor = 0;
    end
  end

  weisz = [1 1 1];
  gelb = [1 1 0];
  rot = [1 0 0];
  gruen = [0 1 0];

  if(ZUSTAND_PRUEFE == 1)
    
    struct_ok = 1;
    par_ok = 1;

    % Pr"ufe of alle Bonds zwei Knoten haben

    anzahl_b = size(LBONDS,1);
    anzahl_e = size(LELEMS,1);
    for i=1:anzahl_b
      if(anzahl_e)
	if( (size(find(LPFEIL(:,i)==+1),1)==1) & ...
	      (size(find(LPFEIL(:,i)==-1),1)==1) )
	  % Alles in Ordnung
	  farbe = weisz;
	else
	  % Es liegt ein Fehler vor
	  farbe = rot;
	  struct_ok = 0;
	end
      else 	    % dh. gar keine Elemente vorhanden
	% Es liegt ein Fehler vor
	farbe = rot;
	struct_ok = 0;
      end
      if(yescolor)
	if(any(get(LBONDS(i,1),'Color')~=farbe))
	  userdata = get(LBONDS(i,1),'UserData');
	  set(userdata(1),'Color',farbe)
	  if(userdata(2))
	    set(userdata(2),'Color',farbe);
	  end
	  set(userdata(3),'Color',farbe);
	end
      end
    end

    % Pr"ufe die Anzahl der Bonds an den Knoten

    anzahl = size(LELEMS,1);
    for i=1:anzahl
      typ = LELEMS(i,2);
      if(size(LPFEIL,2))
	anz_bonds = size(find(LPFEIL(i,:)),2);
      else
	anz_bonds = 0;
      end
      if( (typ==TYP_SE) ...
	    | (typ==TYP_SF) ...
	    | (typ==TYP_C) ...
	    | (typ==TYP_I) ...
	    | (typ==TYP_R) )
	if(anz_bonds==1)
	  if( (typ==TYP_C) ...
		| (typ==TYP_I) ...
		| (typ==TYP_R) )
	    if(LELEMS(i,3))
              farbe = weisz;
            else
              farbe = gelb;
	      par_ok = 0;
            end
          else
            farbe = weisz;
          end
        else
          farbe = rot;
	  struct_ok = 0;
        end
      elseif( (typ==TYP_TF) ...
	    | (typ==TYP_GY) )
        if(anz_bonds==2)
	  if( (size(find(LPFEIL(i,:)==+1),1)==2) ...
		| (size(find(LPFEIL(i,:)==-1),1)==2) )
            farbe = rot;
	    struct_ok = 0;
          else
	    if(LELEMS(i,3))
              farbe = weisz;
            else
              farbe = gelb;
	      par_ok = 0;
            end
          end
        else
          farbe = rot;
	  struct_ok = 0;
        end
      elseif( (typ==TYP_1) ...
	    | (typ==TYP_0) )
        if(anz_bonds>=2)
          farbe = weisz;
        else
          farbe = rot;
	  struct_ok = 0;
        end
      elseif(typ==TYP_XX)
        farbe = rot;
	struct_ok = 0;
      else
      end
      if(yescolor)
	if(any(get(LELEMS(i,1),'Color')~=farbe))
	  userdata = get(LELEMS(i,1),'UserData');
	  set(userdata(1),'Color',farbe);
	  if(userdata(4))
	    set(userdata(2:4),'Color',farbe);
	  end
	end
      end
    end
    if(par_ok)
      Z_PARAMETER = 1;
    else
      Z_PARAMETER = 0;
    end
    if(struct_ok)
      Z_SCHNITZER = 1;
    else
      Z_SCHNITZER = 0;
    end

  elseif(ZUSTAND_PRUEFE == 2)
    anzahl_b = size(LBONDS,1);
    if(yescolor)
      % Mache alle Bond wei"s
      for i=1:anzahl_b
	userdata = get(LBONDS(i,1),'UserData');
	set(userdata(1),'Color',weisz);
	if(userdata(2))
	  set(userdata(2),'Color',weisz);
	end
	set(userdata(3),'Color',weisz);
      end
    end

    % F"arbe der Speicherelemente Bonds ein
    if(anzahl_b)
      anzahl = size(LELEMS,1);
      for i=1:anzahl
	typ = LELEMS(i,2);
	if( (typ==TYP_I) | (typ==TYP_C) )
	  bond = find(LPFEIL(i,:));
	  kausa_knot = LKAUS(i,bond);
	  if(typ==TYP_C)
	    if(kausa_knot==1)
	      farbe = gruen;
	    elseif(kausa_knot==-1)
	      farbe = rot;
	    else    % (kausa_knot==0)
	      farbe = weisz;
	    end
	  else 	    % I-Speicher
	    if(kausa_knot==1)
	      farbe = rot;
	    elseif(kausa_knot==-1)
	      farbe = gruen;
	    else    % (kausa_knot==0)
	      farbe = weisz;
	    end
	  end
	  if(yescolor)
	    userdata = get(LBONDS(bond,1),'UserData');
	    set(userdata(1),'Color',farbe);
	    if(userdata(2))
	      set(userdata(2),'Color',farbe);
	    end
	    set(userdata(3),'Color',farbe);
	  end
	else 	    % Kein Speicher
	  farbe = weisz;
	end 	    % if(Speicher)
	if(yescolor)
	  userdata = get(LELEMS(i,1),'UserData');
	  set(userdata(1),'Color',farbe);
	  if(userdata(4))
	    set(userdata(2:4),'Color',farbe);
	  end
	end
      end 	    % for(alle Elemente)
    end
    
  elseif(ZUSTAND_PRUEFE == 3)  % kausale Widerspr"uche
    % Alle Bonds
    anzahl_bonds = size(LBONDS,1);
    farbe_bond = zeros(anzahl_bonds,3);
    % for alle Bonds
    % a priori werden alle kausalen Bonds gr"un
    % erst bei Widerspruch werden sie rot
    for i=1:anzahl_bonds
      if(size(LELEMS,1))
	hat_kausa = size(find(LKAUS(:,i)),1);
	if(hat_kausa)
	  farbe_bond(i,:) = gruen;
	else
	  farbe_bond(i,:) = weisz;
	end
      else 	    % dh. es sind gar keine Elemente vorhanden
	farbe_bond(i,:) = rot;
      end
    end
    % For alle Elemente
    anzahl_elems = size(LELEMS,1);
    for i=1:anzahl_elems
      typ = LELEMS(i,2);
      if(size(LPFEIL,2))
	bond = find(LPFEIL(i,:));
	anz_b = size(bond,2);
      else
	bond = [];
	anz_b = 0;
      end
      if(anz_b==0)
	farbe_knot = rot;
      else
	kausa_knot = zeros(anz_b,1);
	for j=1:anz_b
	  kausa_knot(j) = LKAUS(i,bond(j));
	end 	    % for(alle Bonds an diesem Element)
	% gibt es an diesem Knoten akausale Bonds?
	if( size(find(kausa_knot==0),1) )
	  farbe_knot = weisz;
	else
	  farbe_knot = gruen;
	end
	% Jetzt alle Arten von Elementen durch-tschecken
	if(typ==TYP_SE)
	  if(kausa_knot==-1)
	    farbe_knot = rot;
	    farbe_bond(bond(1),:) = rot;
	  end
	elseif(typ==TYP_SF)
	  if(kausa_knot==1)
	    farbe_knot = rot;
	    farbe_bond(bond(1),:) = rot;
	  end
	elseif(typ==TYP_C)
	  % C kann keinen Widerspruch verursachen
	elseif(typ==TYP_I)
	  % I kann keinen Widerspruch verursachen
	elseif(typ==TYP_R)
	  % R kann keinen Widerspruch verursachen
	elseif(typ==TYP_TF)
	  if(anz_b==2)
	    if( (kausa_knot(1)*kausa_knot(2))==1 )
	      farbe_knot = rot;
	      farbe_bond(bond(1),:) = rot;
	      farbe_bond(bond(2),:) = rot;
	    end
	  else
	    farbe_knot = rot;
	    for j=1:anz_b
	      farbe_bond(bond(j),:) = rot;
	    end
	  end
	elseif(typ==TYP_GY)
	  if(anz_b==2)
	    if( (kausa_knot(1)*kausa_knot(2))==-1 )
	      farbe_knot = rot;
	      farbe_bond(bond(1),:) = rot;
	      farbe_bond(bond(2),:) = rot;
	    end 
	  else
	    farbe_knot = rot;
	    for j=1:anz_b
	      farbe_bond(bond(j),:) = rot;
	    end
	  end
	elseif(typ==TYP_1)
	  e_bonds = find(kausa_knot==1);
	  a_bonds = find(kausa_knot==0);
	  if( size(e_bonds,1) > 1 )
	    farbe_knot = rot;
	    for j=1:size(e_bonds,1)
	      farbe_bond(bond(e_bonds(j)),:) = rot;
	    end
	  elseif( (size(e_bonds,1)+size(a_bonds,1))==0 )
	    farbe_knot = rot;
	    for j=1:anz_b
	      farbe_bond(bond(j),:) = rot;
	    end
	  end
	elseif(typ==TYP_0)
	  f_bonds = find(kausa_knot==-1);
	  a_bonds = find(kausa_knot==0);
	  if( size(f_bonds,1) > 1 )
	    farbe_knot = rot;
	    for j=1:size(f_bonds,1)
	      farbe_bond(bond(f_bonds(j)),:) = rot;
	    end
	  elseif( (size(f_bonds,1)+size(a_bonds,1))==0 )
	    farbe_knot = rot;
	    for j=1:anz_b
	      farbe_bond(bond(j),:) = rot;
	    end
	  end
	elseif(typ==TYP_XX)
	  farbe_knot = rot;
	else
	end
      end
      if(yescolor)
	% F"arbe das Element ein
	userdata = get(LELEMS(i,1),'UserData');
	set(userdata(1),'Color',farbe_knot);
	if(userdata(4))
	  set(userdata(2:4),'Color',farbe_knot);
	end
      end
    end  % for(alle Elemente)
    % F"arbe alle Bonds ein
    kausok = 1;
    kausvoll = 1;
    anzahl_bonds = size(LBONDS,1);
    for i=1:anzahl_bonds
      if(yescolor)
	userdata = get(LBONDS(i,1),'UserData');
	set(userdata(1),'Color',farbe_bond(i,:));
	if(userdata(2))
	  set(userdata(2),'Color',farbe_bond(i,:));
	end
	set(userdata(3),'Color',farbe_bond(i,:));
      end
      if(farbe_bond(i,:)==rot)
	kausok = 0;
      end
      if( (farbe_bond(i,:)==rot) | (farbe_bond(i,:)==weisz) )
	kausvoll = 0;
      end
    end  % for(alle Bonds)
    if(kausok)
      Z_KAUSOK = 1;
    else
      Z_KAUSOK = 0;
    end
    if(kausvoll)
      Z_KAUSVOLL = 1;
    else
      Z_KAUSVOLL = 0;
    end

  elseif(ZUSTAND_PRUEFE == -1)
    % Mache alle Bonds wei"s
    anzahl = size(LBONDS,1);
    for i=1:anzahl
      userdata = get(LBONDS(i,1),'UserData');
      set(userdata(1),'Color',weisz);
      if(userdata(2))
	set(userdata(2),'Color',weisz);
      end
      set(userdata(3),'Color',weisz);
    end
    % Mache alle Elemente wei"s
    anzahl = size(LELEMS,1);
    for i=1:anzahl
      userdata = get(LELEMS(i,1),'UserData');
      set(userdata(1),'Color',weisz);
      if(userdata(4))
	set(userdata(2:4),'Color',weisz);
      end
    end
  end % switch(ZUSTAND_PRUEFE)


elseif(action == F_check_par)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Pru"fe ob alle Elemente einen Parameter haben %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  ok = 1;
  anzahl = size(LELEMS,1);
  for i=1:anzahl
    typ = LELEMS(i,2);
    if( (typ==TYP_C) ...
	  | (typ==TYP_I) ...
	  | (typ==TYP_R) ...
	  | (typ==TYP_TF) ...
	  | (typ==TYP_GY) )
      if(~(LELEMS(i,3)))
	ok = 0;
	break;
      end
    end
  end
  Z_PARAMETER = ok;


elseif(action == F_par_cb)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % CallBack-String f"ur die Parametereingabe-uicontrol-edit-box %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %
  %  in1 == nro ... Zeile der Element-Liste
  %  

  nro = in1;

  neu_par_str = get(H_EDIT(2),'String');
  neu_par = str2num(neu_par_str);
  LELEMS(nro,3) = neu_par;
  set(H_EDIT(1),'Visible','off');
  set(H_EDIT(2),'Visible','off');
  kalibond(F_elem,'redraw2',nro);
  kalibond(F_modified_on,'parameter');
  kalibond(F_message_off);


elseif(action == F_ask_matrizen)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Frage nach der Zustandsmatrizen Namen %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  h_askbox = figure('numbertitle','off', ...
                    'name',[BILD_NAME 'state-space matrices'' names'], ...
                    'menubar','none');
  set(get(h_askbox,'currentaxes'),'visible','off');

  % Betrifft: Die folgenden 5 Programmzeilen
  % Den Trick mit der Schriftgr"o"se habe ich der
  % MatLab-Demo "`choices.m"' entnommen
  hh = text(0.1,0.1,0,'Aq','units','pixel');
  yedge = get(hh,'extent');
  delete(hh);
  xsize = 1.2*yedge(3);
  ysize = 1.2*yedge(4);

  for i=1:6
    uicontrol('style','text', ...
	'units','pixel', ...
	'position', [5 (6-i)*(ysize+4)+4 xsize ysize], ...
	'string',setstr(i-1+abs(['A'])) );

    h_ask(i) = uicontrol('style','edit', ...
	'units','pixel', ...
	'position', [10+xsize (6-i)*(ysize+4)+4 20*xsize ysize], ... 
	'string',deblank(MATR_NAM(i,:)) );
  end % for i=1:6
  
  g1 = get(h_askbox,'Position');
  gx = 15+21*xsize;
  gy = 6*(ysize+4)+8;
  groesze = [g1(1)+0.5*(g1(3)-gx) g1(2)+g1(4)-gy gx gy];
  set(h_askbox,'Position',groesze);

  uimenu(h_askbox, ...
      'label',kalibond(F_label,'&OK'), ...
      'accelerator',kalibond(F_acc,'o'), ...
      'userdata',h_ask, ...
      'callback',['kalibond(',int2str(F_get_matrizen),');']);

  uimenu(h_askbox, ...
      'label',kalibond(F_label,'&Cancel'), ...
      'accelerator',kalibond(F_acc,'g'), ...
      'userdata',h_ask, ...
      'callback',['kalibond(',int2str(F_cancel_matrizen),');']);


elseif(action == F_cancel_matrizen)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Zustandsmatrizen-Namen-Askbox: Cancel %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  close;


elseif(action == F_get_matrizen)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Zustandsmatrizen-Namen-Askbox: OK %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  h_ask = get(get(gcf,'currentmenu'),'userdata');
  MATR_NAM = get(h_ask(1),'string');
  for i=2:6
    MATR_NAM = str2mat(MATR_NAM, get(h_ask(i),'string'));
  end % for i=1:6
  MATR_OUT = ['['];
  for i=1:6
    MATR_OUT = [MATR_OUT deblank(MATR_NAM(i,:)) ','];
  end % for i=1:6
  MATR_OUT = MATR_OUT(:,1:size(MATR_OUT,2)-1);
  MATR_OUT =[MATR_OUT ']'];
  set(H_M_RECHNE, ...
      'callback',[MATR_OUT ' = kalibond(',int2str(F_rechne1),')']);
  close;
  kalibond(F_modified_on,'matrizen');


elseif(action == F_ask_ausgang)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Frage nach dem Ausgangsvektor %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  h_askbox = figure('numbertitle','off', ...
      'name',[BILD_NAME 'output-vector'], ...
      'menubar','none');
  set(get(h_askbox,'currentaxes'),'visible','off');
  
  % Betrifft: Die folgenden 5 Programmzeilen
  % Den Trick mit der Schriftgr"o"se habe ich der
  % MatLab-Demo "`choices.m"' entnommen
  hh = text(0.1,0.1,0,'Aq','units','pixel');
  yedge = get(hh,'extent');
  delete(hh);
  ysize = 1.2*yedge(4);
  ss = get(h_askbox,'Position');
  h_ask = uicontrol('style','edit', ...
      'units','pixel', ...
      'position', [5 4 ss(3)-10 ysize], ...
      'string',OUT_VEC);
  
  g1 = get(h_askbox,'Position');
  gx = g1(3);
  gy = ysize+8;
  groesze = [g1(1) g1(2)+g1(4)-gy g1(3) gy];
  set(h_askbox,'Position',groesze);

  uimenu(h_askbox, ...
      'label',kalibond(F_label,'&OK'), ...
      'accelerator',kalibond(F_acc,'o'), ...
      'userdata',h_ask, ...
      'callback',['kalibond(',int2str(F_get_ausgang),');']);
  
  uimenu(h_askbox, ...
      'label',kalibond(F_label,'&Cancel'), ...
      'accelerator',kalibond(F_acc,'g'), ...
      'userdata',h_ask, ...
      'callback',['kalibond(',int2str(F_cancel_ausgang),');']);
  
elseif(action == F_cancel_ausgang)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Ausgangsvektor-Askbox: Cancel %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  close;


elseif(action == F_get_ausgang)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Ausgangsvektor-Askbox: OK %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  h_ask = get(get(gcf,'currentmenu'),'userdata');
  OUT_VEC = get(h_ask,'string');
  close;
  kalibond(F_modified_on,'outvec');


elseif(action == F_imp_antw)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Standard-Simulation: Impulsantwort %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if( (find(MATRIX_E)==[]) & (find(MATRIX_F)==[]) )
    newplot;
    impulse(MATRIX_A,MATRIX_B,MATRIX_C,MATRIX_D);
  else
    kalibond(F_message_on,['no impulse-response, since dot_u']);
  end
  
elseif(action == F_spr_antw)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Standard-Simulation: Sprungantwort %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if( (find(MATRIX_E)==[]) & (find(MATRIX_F)==[]) )
    newplot;
    step(MATRIX_A,MATRIX_B,MATRIX_C,MATRIX_D);
  else
    siz_x = size(MATRIX_A,1);
    siz_u = size(MATRIX_E,2);
    hat_a = [MATRIX_A MATRIX_B; ...
	zeros(siz_u,siz_x) zeros(siz_u,siz_u)];
    hat_b = [MATRIX_E; eye(siz_u)];
    hat_c = [MATRIX_C MATRIX_D];
    hat_d = MATRIX_F;
    newplot;
    impulse(hat_a,hat_b,hat_c,hat_d);
  end


elseif(action == F_kausaliere)
  %%%%%%%%%%%%%%%%%
  % Kausaliere !  %
  %%%%%%%%%%%%%%%%%
  
  set(H_BILD,'pointer','watch');
  drawnow;
  BONDLIST = [];
  kauslist = [];
  anz_bonds = size(LPFEIL,2);
  for i=1:anz_bonds
    znro_von = find(LPFEIL(:,i)==(+1));
    znro_nach = find(LPFEIL(:,i)==(-1));
    BONDLIST = [BONDLIST; znro_von znro_nach];
    kauslist = [kauslist; LKAUS(znro_von,i)];
  end
  [kauslist,konflikt] = kalibond(F_kalikaus,F2_start,kauslist);
  for i=1:anz_bonds
    if(kauslist(i,1)==(+1))
      kaus_str = 'effort';
    elseif(kauslist(i,1)==(-1))
      kaus_str = 'flow';
    else
      kaus_str = 'acausal';
    end
    kalibond(F_bond,'redraw',i,kaus_str);
  end
  if(konflikt)
    kalibond(F_message_on,'*** Kalikaus: causal conflict ***');
    h_andere = get(H_M_O_W,'UserData');
    set(h_andere,'checked','off');
    set(H_M_O_W,'checked','on');
    ZUSTAND_PRUEFE = 3;
    %kalibond('pruefe');
    %set(H_M_RECHNE,'enable','off');
    %set(H_M_SIMUL,'enable','off');
    %Z_KAUSOK = 0;
  else
    % Suche Anzahl der integralen bzw. differentiellen Speicher
    anzahl_elems = size(LELEMS,1);
    integ = 0;
    diffe = 0;
    for i=1:anzahl_elems
      typ = LELEMS(i,2);
      if( (typ==TYP_C) | (typ==TYP_I) )
	kaus = LKAUS(i,find(LKAUS(i,:)));
	if(typ==TYP_C)
	  if(kaus==(+1))
	    integ = integ + 1;
	  elseif(kaus==(-1))
	    diffe = diffe + 1;
	  end
	elseif(typ==TYP_I)
	  if(kaus==(-1))
	    integ = integ + 1;
	  elseif(kaus==(+1))
	    diffe = diffe + 1;
	  end
	end
      end % If Speicher
    end % For alle Elemente
    if(integ==0)
      i_str = 'no integrating, ';
    else
      i_str = [int2str(integ),' integrating, '];
    end
    if(diffe==0)
      d_str = 'no differentiating ';
    else
      d_str = [int2str(diffe),' differentiating '];
    end
    if( (diffe+integ==0) ...
	  | (diffe>1) ...
	  | (integ>1) )
      s_str = 'energy storing elements';
    else
      s_str = 'energy storing element';
    end
    kalibond(F_message_on,['success: ',i_str,d_str,s_str]);
  end
  kalibond(F_modified_on,'kausa');
  set(H_BILD,'pointer','arrow');
  drawnow;
  
  
elseif(action == F_kalikaus)
  %%%%%%%%%%%%
  % KaliKaus %
  %%%%%%%%%%%%
  
  if(in1 == F2_start)
    kausas = in2;
    [kausas,anzdiff,konflikt] = kalibond(F_kalikaus,F2_bgfk,kausas);
    out1 = kausas;
    out2 = konflikt;
    
  elseif(in1 == F2_bgfk)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Bondgraph fertig kausalieren %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,anzdiff,konflikt] = bgfk(kauslist)
    %  
    %  kauslist ... Kausalit"atsliste
    %  anzdiff .... Anzahl der differentiell zugewiesenen Kausalit"aten
    %  konflikt ... Ist ein Konflikt aufgetreten?

    %	ndb ...... Nummer des Bonds
    %	typ ...... Typ des sch"onsten akausalen Knotens
    %	scapna ... Function: SCAP n"achster akausaler Bond
    %	nrosk .... Nummer des sch"oneren Knotens
    %	nroak .... Nummer des anderen Knotens
    %	lpf ...... Leistungspfeil bezogen auf den sch"oneren Knoten

    kauslist = in2;

    [typ,ndb] = kalibond(F_kalikaus,F2_scapna,kauslist);

    if(typ == TYP_SE)
      [nrosk,lpf,nroak] = kalibond(F_kalikaus,F2_vtb,ndb,typ);
      [kauslist,anzdiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_zuwei_se,ndb,lpf,nroak,kauslist);
    elseif(typ == TYP_SF)
      [nrosk,lpf,nroak] = kalibond(F_kalikaus,F2_vtb,ndb,typ);
      [kauslist,anzdiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_zuwei_sf,ndb,lpf,nroak,kauslist);
    elseif(typ == TYP_C)
      [nrosk,lpf,nroak] = kalibond(F_kalikaus,F2_vtb,ndb,typ);
      [kauslist,anzdiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_zuwei_c,ndb,lpf,nroak,kauslist);
    elseif(typ == TYP_I)
      [nrosk,lpf,nroak] = kalibond(F_kalikaus,F2_vtb,ndb,typ);
      [kauslist,anzdiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_zuwei_i,ndb,lpf,nroak,kauslist);
    elseif(typ == TYP_R)
      [nrosk,lpf,nroak] = kalibond(F_kalikaus,F2_vtb,ndb,typ);
      [kauslist,anzdiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_zuwei_r,ndb,lpf,nroak,kauslist);
    elseif(~(typ == TYP_KEINER_DA)) % innerer Bond
      [nrovk,nronk] = kalibond(F_kalikaus,F2_vib,ndb);
      [kauslist,konflikt] = ...
	  kalibond(F_kalikaus,F2_zuwei_ib,nrovk,nronk,ndb,kauslist);
      anzdiff = 0;
    else 	    % fertig
      konflikt = FALSE;
      anzdiff = 0;
    end
    
    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;

    
  elseif(in1 == F2_scapna)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % SCAP n"achster akausaler Bond %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [typ,nrobond] = scapna(kauslist)
    %  
    %  typ ....... Typ des gefundenen Knotens
    %  nrobond ... Nummer des gefundenen Bonds
    %  
    %  FOR INTERNAL USE ONLY !
    %  
    %  Johann Kallinovsky
    %  Diplomarbeit

    kauslist = in2;

    typ = TYP_KEINER_DA;
    nrobond = 0;

    %	listak ... Liste der Indices der akausalen Bonds
    %	anzak .... Anzahl der akausalen Bonds
    %	vksn ..... Von-Knoten SCAP-Nummer
    %	nksn ..... Nach-Knoten SCAP-Nummer

    listak = find(~kauslist);
    anzak = size(listak,1);

    if(anzak)
      for i=1:anzak
	vksn = LELEMS(BONDLIST(listak(i),1),2);
	nksn = LELEMS(BONDLIST(listak(i),2),2);
	if(vksn < typ)
	  typ = vksn;
	  nrobond = listak(i);
	end
	if(nksn < typ)
	  typ = nksn;
	  nrobond = listak(i);
	end
      end
    end

    out1 = typ;
    out2 = nrobond;

    
  elseif(in1 == F2_vib)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Vorbereiten innerer Bond %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [nrovk,nronk] = vib(nrobond)
    %  
    %  nrobond ... Nummer des Bonds
    %  
    %  nrovk ..... Nummer des VON-Knotens
    %  nronk ..... Nummer des NACH-Knotens
    %  

    nrobond = in2;

    nrovk = BONDLIST(nrobond,1);
    nronk = BONDLIST(nrobond,2);

    out1 = nrovk;
    out2 = nronk;


  elseif(in1 == F2_vtb)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Vorbereiten Terminaler Bond %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [nrosk,lpf,nroak] = vtb(nrobond,typsk)
    %  
    %  nrosk ..... Nummer des sch"oneren Knotens
    %  nroak ..... Nummer des anderen Knotens
    %  lpf ....... Leistungspfeil bezogen auf den sch"oneren Knoten
    %  nrobond ... Nummer des Bonds
    %  typsk ..... Typ des sch"oneren Knotens
    %  

    nrobond = in2;
    typsk = in3;

    if(LELEMS(BONDLIST(nrobond,1),2) == typsk)
      nrosk = BONDLIST(nrobond,1);
      nroak = BONDLIST(nrobond,2);
      lpf = WEG_VOM_KNOTEN;
    else
      nrosk = BONDLIST(nrobond,2);
      nroak = BONDLIST(nrobond,1);
      lpf = HIN_ZUM_KNOTEN;
    end

    out1 = nrosk;
    out2 = lpf;
    out3 = nroak;


  elseif(in1 == F2_zuwei_se)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Zuweisen eines SE-Bonds %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    % [kauslist,anzdiff,konflikt] = zuwei_se(nrob,lpf,nroak,kauslist)
    % 
    % nrob ....... Nummer des Bonds
    % lpf ........ Leistungspfeil bezogen auf den SE-Knoten
    % nroak ...... Nummer des anderen Knotens
    % kauslist ... Kausalit"atsliste
    % 
    % kauslist ... Kausalit"atsliste (neu)
    % anzdiff .... Anzahl der differentiellen Kausali"aten
    % konflikt ... Ist ein Konflikt aufgetreten? (TRUE | FALSE)
    % 

    nrob = in2;
    lpf = in3;
    nroak = in4;
    kauslist = in5;

    [kauslist,anzdiff,konflikt] = ...
	kalibond(F_kalikaus,F2_bsua,nrob,WEG_VOM_KNOTEN*lpf,nroak,kauslist);

    if(konflikt == FALSE)
      [kauslist,neudiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_bgfk,kauslist);
    end
    if(konflikt == FALSE)
      anzdiff = anzdiff + neudiff;
    end

    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;


  elseif(in1 == F2_zuwei_sf)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Zuweisen eines SF-Bonds %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,anzdiff,konflikt] = zuwei_sf(nrob,lpf,nroak,kauslist)
    %  
    %  nrob ....... Nummer des Bonds
    %  lpf ........ Leistungspfeil bezogen auf den SF-Knoten
    %  nroak ...... Nummer des anderen Knotens
    %  kauslist ... Kausalit"atsliste
    %  
    %  kauslist ... Kausalit"atsliste (neu)
    %  anzdiff .... Anzahl der differentiellen Kausali"aten
    %  konflikt ... Ist ein Konflikt aufgetreten? (TRUE | FALSE)
    %  

    nrob = in2;
    lpf = in3;
    nroak = in4;
    kauslist = in5;

    [kauslist,anzdiff,konflikt] = ...
	kalibond(F_kalikaus,F2_bsua,nrob,HIN_ZUM_KNOTEN*lpf,nroak,kauslist);

    if(konflikt == FALSE)
      [kauslist,neudiff,konflikt] = ...
	  kalibond(F_kalikaus,F2_bgfk,kauslist);
    end
    if(konflikt == FALSE)
      anzdiff = anzdiff + neudiff;
    end

    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;


  elseif(in1 == F2_zuwei_c)
    %%%%%%%%%%%%%%%%%%%%%%%%%%
    % Zuweisen eines C-Bonds %
    %%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,anzdiff,konflikt] = zuwei_c(nrob,lpf,nroak,kauslist)
    %  
    %  nrob ....... Nummer des Bonds
    %  lpf ........ Leistungspfeil bezogen auf den SF-Knoten
    %  nroak ...... Nummer des anderen Knotens
    %  kauslist ... Kausalit"atsliste
    %  
    %  kauslist ... Kausalit"atsliste (neu)
    %  anzdiff .... Anzahl der differentiellen Kausali"aten
    %  konflikt ... Ist ein Konflikt aufgetreten? (TRUE | FALSE)
    %  

    nrob = in2;
    lpf = in3;
    nroak = in4;
    kauslist = in5;

    [kauslist_A,anzdiff_A,konflikt_A] = ...
	kalibond(F_kalikaus,F2_bsua,nrob,WEG_VOM_KNOTEN*lpf,nroak,kauslist);

    if(konflikt_A == FALSE)
      [kauslist_A,neudiff_A,konflikt_A] = ...
	  kalibond(F_kalikaus,F2_bgfk,kauslist_A);
    end
    if(konflikt_A == FALSE)
      anzdiff_A = anzdiff_A + neudiff_A;
    end
    if( (konflikt_A == FALSE) & (anzdiff_A <=1) )
      kauslist = kauslist_A;
      anzdiff = anzdiff_A;
      konflikt = FALSE;
    else
      [kauslist_B,anzdiff_B,konflikt_B] = ...
	  kalibond(F_kalikaus,F2_bsua,nrob,HIN_ZUM_KNOTEN*lpf, ...
	  nroak,kauslist);
      if(konflikt_B == FALSE)
	[kauslist_B,neudiff_B,konflikt_B] = ...
	    kalibond(F_kalikaus,F2_bgfk,kauslist_B);
      end
      if(konflikt_B == FALSE)
	anzdiff_B = anzdiff_B + neudiff_B;
      end
      if( (konflikt_A == TRUE) & (konflikt_B == TRUE) )
	konflikt = TRUE;
      elseif(konflikt_A == TRUE)
	kauslist = kauslist_B;
	anzdiff = anzdiff_B + 1;
	konflikt = FALSE;
      elseif(konflikt_B == TRUE)
	kauslist = kauslist_A;
	anzdiff = anzdiff_A;
	konflikt = FALSE;
      elseif(anzdiff_A <= (anzdiff_B + 1))
	kauslist = kauslist_A;
	anzdiff = anzdiff_A;
	konflikt = FALSE;
      else
	kauslist = kauslist_B;
	anzdiff = anzdiff_B;
	konflikt = FALSE;
      end
    end

    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;
  

  elseif(in1 == F2_zuwei_i)
    %%%%%%%%%%%%%%%%%%%%%%%%%%
    % Zuweisen eines I-Bonds %
    %%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,anzdiff,konflikt] = zuwei_i(nrob,lpf,nroak,kauslist)
    %  
    %  nrob ....... Nummer des Bonds
    %  lpf ........ Leistungspfeil bezogen auf den SF-Knoten
    %  nroak ...... Nummer des anderen Knotens
    %  kauslist ... Kausalit"atsliste
    %  
    %  kauslist ... Kausalit"atsliste (neu)
    %  anzdiff .... Anzahl der differentiellen Kausali"aten
    %  konflikt ... Ist ein Konflikt aufgetreten? (TRUE | FALSE)
    %  

    nrob = in2;
    lpf = in3;
    nroak = in4;
    kauslist = in5;
    
    [kauslist_A,anzdiff_A,konflikt_A] = ...
	kalibond(F_kalikaus,F2_bsua,nrob,HIN_ZUM_KNOTEN*lpf,nroak,kauslist);

    if(konflikt_A == FALSE)
      [kauslist_A,neudiff_A,konflikt_A] = ...
	  kalibond(F_kalikaus,F2_bgfk,kauslist_A);
    end
    if(konflikt_A == FALSE)
      anzdiff_A = anzdiff_A + neudiff_A;
    end
    if( (konflikt_A == FALSE) & (anzdiff_A <=1) )
      kauslist = kauslist_A;
      anzdiff = anzdiff_A;
      konflikt = FALSE;
    else
      [kauslist_B,anzdiff_B,konflikt_B] = ...
	  kalibond(F_kalikaus,F2_bsua,nrob,WEG_VOM_KNOTEN*lpf, ...
	  nroak,kauslist);
      if(konflikt_B == FALSE)
	[kauslist_B,neudiff_B,konflikt_B] = ...
	    kalibond(F_kalikaus,F2_bgfk,kauslist_B);
      end
      if(konflikt_B == FALSE)
	anzdiff_B = anzdiff_B + neudiff_B;
      end
      if( (konflikt_A == TRUE) & (konflikt_B == TRUE) )
	konflikt = TRUE;
      elseif(konflikt_A == TRUE)
	kauslist = kauslist_B;
	anzdiff = anzdiff_B + 1;
	konflikt = FALSE;
      elseif(konflikt_B == TRUE)
	kauslist = kauslist_A;
	anzdiff = anzdiff_A;
	konflikt = FALSE;
      elseif(anzdiff_A <= (anzdiff_B + 1))
	kauslist = kauslist_A;
	anzdiff = anzdiff_A;
	konflikt = FALSE;
      else
	kauslist = kauslist_B;
	anzdiff = anzdiff_B;
	konflikt = FALSE;
      end
    end

    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;


  elseif(in1 == F2_zuwei_r)
    %%%%%%%%%%%%%%%%%%%%%%%%%%
    % Zuweisen eines R-Bonds %
    %%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,anzdiff,konflikt] = zuwei_r(nrob,lpf,nroak,kauslist)
    %  
    %  nrob ....... Nummer des Bonds
    %  lpf ........ Leistungspfeil bezogen auf den SF-Knoten
    %  nroak ...... Nummer des anderen Knotens
    %  kauslist ... Kausalit"atsliste
    %  
    %  kauslist ... Kausalit"atsliste (neu)
    %  anzdiff .... Anzahl der differentiellen Kausali"aten
    %  konflikt ... Ist ein Konflikt aufgetreten? (TRUE | FALSE)
    %  

    nrob = in2;
    lpf = in3;
    nroak = in4;
    kauslist = in5;

    [kauslist_A,anzdiff_A,konflikt_A] = ...
	kalibond(F_kalikaus,F2_bsua,nrob,HIN_ZUM_KNOTEN*lpf,nroak,kauslist);

    if(konflikt_A == FALSE)
      [kauslist_A,neudiff_A,konflikt_A] = ...
	  kalibond(F_kalikaus,F2_bgfk,kauslist_A);
    end
    if(konflikt_A == FALSE)
      kauslist = kauslist_A;
      anzdiff = 0;
      konflikt = FALSE;
    else
      [kauslist_B,anzdiff_B,konflikt_B] = ...
	  kalibond(F_kalikaus,F2_bsua,nrob,WEG_VOM_KNOTEN*lpf, ...
	  nroak,kauslist);
      if(konflikt_B == FALSE)
	[kauslist_B,neudiff_B,konflikt_B] = ...
	    kalibond(F_kalikaus,F2_bgfk,kauslist_B);
      end
      if(konflikt_B == FALSE)
	kauslist = kauslist_B;
	anzdiff = 0;
	konflikt = FALSE;
      else
	konflikt = TRUE;
      end
    end

    %
    % Anm.: _A, _B, differentielle k"onnen eventuell wergelassen werden!
    % 

    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;


  elseif(in1 == F2_zuwei_ib)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Zuweisen eines inneren Bonds %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,konflikt] = zuwei_ib(nrovk,nronk,nrob,kauslist)
    %  
    %  nrovk ...... Nummer des VON-Knotens
    %  nronk ...... Nummer des NACH-Knotens
    %  nrob ....... Nummer des Bonds
    %  kauslist ... Kausalit"atsliste
    %  
    %  kauslist ... Kausalit"atsliste (neu)
    %  konflikt ... Ist ein Konflikt aufgetreten? (TRUE | FALSE)
    %  

    nrovk = in2;
    nronk = in3;
    nrob = in4;
    kauslist = in5;

    [kauslist_A,anzdiff_A,konflikt_A] = ...
	kalibond(F_kalikaus,F2_bsua,nrob,WEG_VOM_KNOTEN,nronk,kauslist);

    if(konflikt_A == FALSE)
      [kauslist_A,neudiff_A,konflikt_A] = ...
	  kalibond(F_kalikaus,F2_bgfk,kauslist_A);
    end
    if(konflikt_A == FALSE)
      kauslist = kauslist_A;
      anzdiff = 0;
      konflikt = FALSE;
    else
      [kauslist_B,anzdiff_B,konflikt_B] = ...
	  kalibond(F_kalikaus,F2_bsua,nrob,HIN_ZUM_KNOTEN,nrovk,kauslist);
      if(konflikt_B == FALSE)
	[kauslist_B,neudiff_B,konflikt_B] = ...
	    kalibond(F_kalikaus,F2_bgfk,kauslist_B);
      end
      if(konflikt_B == FALSE)
	kauslist = kauslist_B;
	anzdiff = 0;
	konflikt = FALSE;
      else
	konflikt = TRUE;
      end
    end

    %
    % Anm.: _A, _B, differentielle k"onnen eventuell wergelassen werden!
    % 

    out1 = kauslist;
    out2 = konflikt;


  elseif(in1 == F2_bsua)
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Bond setzen und ausbreiten %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [kauslist,anzdiff,konflikt] = bsua(nb,kb,nk,kauslist)
    %  
    %  kauslist ... Kausalit"atsliste
    %  anzdiff .... Anzahl der differentiell gesetzten Kausalit"aten
    %  konflikt ... Ist ein Konflikt aufgetreten?
    %  nb ......... Nummer des neu zu setzenden Bonds
    %  kb ......... Kausalit"at des neu zu setzenden Bonds
    %               (bezogen auf den Leistungspfeil)
    %  nk ......... Nummer des n"achsten Knotens
    %  

    nb = in2;
    kb = in3;
    nk = in4;
    kauslist = in5;

    kauslist(nb) = kb;

    ldbak = kalibond(F_kalikaus,F2_bak,nk,kauslist);

    [status,anzdiff] = kalibond(F_kalikaus,F2_adk,nk,ldbak);

    if(status == STATUS_KONFLIKT)
      konflikt = TRUE;
      out1 = kauslist;
      out2 = anzdiff;
      out3 = konflikt;
      return;
    else
      konflikt = FALSE;
    end

    if( (status == STATUS_WEG) | (status == STATUS_HIN) )
      if(status == STATUS_WEG)
	richtung = WEG_VOM_KNOTEN;
      else
	richtung = HIN_ZUM_KNOTEN;
      end
      for i=1:size(ldbak,1)
	if(kauslist(ldbak(i,1)) == 0) % dh. Bond noch akausal
	  [kauslist,neudiff,konflikt] = ...
	      kalibond(F_kalikaus,F2_bsua, ...
	      ldbak(i,1),richtung*ldbak(i,4),ldbak(i,2),kauslist);
	  if(konflikt == TRUE)
	    out1 = kauslist;
	    out2 = anzdiff;
	    out3 = konflikt;
	    return;
	  end
	  anzdiff = anzdiff + neudiff;
	end
      end
    end

    out1 = kauslist;
    out2 = anzdiff;
    out3 = konflikt;


  elseif(in1 == F2_bak)
    %%%%%%%%%%%%%%%%%%%
    % Bonds am Knoten %
    %%%%%%%%%%%%%%%%%%%
    %
    %  [ldbak] = bak(nk,kauslist)
    %  
    %  ldbak ...... Liste der Bonds am Knoten
    %  nk ......... Nummer des zentralen Knotens
    %  kauslist ... Kausalit"atsliste
    %  

    nk = in2;
    kauslist = in3;

    ldbak = [];

    %  nrolist ... Liste der gefundenen Bondnummern
    %  vonnach ... Ist der gefundene Bond ein VON-Knoten (vonnach == 1)
    %              oder ein NACH-Knoten (vonnach == 2)
    %  anzbond ... Anzahl der gefundenen Bonds

    [nrolist,vonnach] = find(BONDLIST == nk);
    anzbond = size(nrolist,1);

    if(anzbond)
      for i=1:anzbond
	if(vonnach(i) == 1) % ein VON-Knoten
	  ldbak = [ldbak;nrolist(i) BONDLIST(nrolist(i),2) ...
		  WEG_VOM_KNOTEN*kauslist(nrolist(i)) WEG_VOM_KNOTEN];
	else 	    % ein NACH-Knoten
	  ldbak = [ldbak;nrolist(i) BONDLIST(nrolist(i),1) ...
		  HIN_ZUM_KNOTEN*kauslist(nrolist(i)) HIN_ZUM_KNOTEN];
	end
      end
    end

    out1 = ldbak;


  elseif(in1 == F2_adk)
    %%%%%%%%%%%%%%%%%%%%%%%
    % Analyse des Knotens %
    %%%%%%%%%%%%%%%%%%%%%%%
    %
    %  [status,anzdiff] = adk(nro,ldbak)
    %  
    %  status .... == Konflikt
    %               | Ausbreitungswelle fertig
    %               | Knoten eindeutig: Alle noch freien Bonds haben
    %                                   WEG_VOM_KNOTEN-Kausalit"at
    %               | Knoten eindeutig: Alle noch freien Bons haben
    %                                   HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %                        zugewiesen.
    %               | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  nro ....... Nro des zu untersuchenden Knotens
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    nro = in2;
    ldbak = in3;

    typ = LELEMS(nro,2);

    if(typ == TYP_SE)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_se,ldbak);
    elseif(typ == TYP_SF)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_sf,ldbak);
    elseif(typ == TYP_C)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_c,ldbak);
    elseif(typ == TYP_I)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_i,ldbak);
    elseif(typ == TYP_R)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_r,ldbak);
    elseif(typ == TYP_1)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_1,ldbak);
    elseif(typ == TYP_0)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_0,ldbak);
    elseif(typ == TYP_TF)
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_tf,ldbak);
    else 	    % typ == TYP_GY
      [status,anzdiff] = kalibond(F_kalikaus,F2_analy_gy,ldbak);
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_sf)
    %%%%%%%%%%%%%%
    % Analyse SF %
    %%%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_sf(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %	ldbak ..... Liste der Bonds am Knoten
    %	

    ldbak = in2;

    anzdiff = 0;

    if(ldbak(1,3) == HIN_ZUM_KNOTEN)
      status = STATUS_ENDE_AUSBR;
    else
      status = STATUS_KONFLIKT;
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_se)
    %%%%%%%%%%%%%%
    % Analyse SE %
    %%%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_se(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %	anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %	                      zugewiesen.
    %	 	     | 1 d.h. es WURDE differentielle Kausalit"at 
    %                         zugewiesen.
    %	ldbak ..... Liste der Bonds am Knoten
    %	

    ldbak = in2;

    anzdiff = 0;

    if(ldbak(1,3) == WEG_VOM_KNOTEN)
      status = STATUS_ENDE_AUSBR;
    else
      status = STATUS_KONFLIKT;
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_c)
    %%%%%%%%%%%%%
    % Analyse C %
    %%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_c(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    ldbak = in2;

    status = STATUS_ENDE_AUSBR;

    if(ldbak(1,3) == WEG_VOM_KNOTEN)
      anzdiff = 0;
    else
      anzdiff = 1;
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_i)
    %%%%%%%%%%%%%
    % Analyse I %
    %%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_i(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    ldbak = in2;

    status = STATUS_ENDE_AUSBR;

    if(ldbak(1,3) == HIN_ZUM_KNOTEN)
      anzdiff = 0;
    else
      anzdiff = 1;
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_r)
    %%%%%%%%%%%%%
    % Analyse R %
    %%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_r(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %

    ldbak = in2;

    status = STATUS_ENDE_AUSBR;
    anzdiff = 0;

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_0)
    %%%%%%%%%%%%%
    % Analyse 0 %
    %%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_0(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    ldbak = in2;

    anzdiff = 0;

    effort = 0;
    flow = 0;
    akausal = 0;

    anzbonds = size(ldbak,1);

    for i=1:anzbonds
      if(ldbak(i,3) == HIN_ZUM_KNOTEN)
	effort = effort + 1;
      elseif(ldbak(i,3) == AKAUSAL)
	akausal = akausal + 1;
      else 	    % ldbak(1,3) == WEG_VOM_KNOTEN
	flow = flow + 1;
      end
    end

    if(effort > 1)
      status = STATUS_KONFLIKT;
    elseif(effort == 1)
      if(akausal > 0)
	status = STATUS_WEG;
      else 	    % akausal == 0
	status = STATUS_ENDE_AUSBR;
      end
    else 	    % effort == 0
      if(akausal > 1)
	status = STATUS_ENDE_AUSBR;
      elseif(akausal == 1)
	status = STATUS_HIN;
      else 	    % akausal == 0
	status = STATUS_KONFLIKT;
      end
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_1)
    %%%%%%%%%%%%%
    % Analyse 1 %
    %%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_1(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    ldbak = in2;

    anzdiff = 0;

    effort = 0;
    flow = 0;
    akausal = 0;

    anzbonds = size(ldbak,1);

    for i=1:anzbonds
      if(ldbak(i,3) == HIN_ZUM_KNOTEN)
	effort = effort + 1;
      elseif(ldbak(i,3) == AKAUSAL)
	akausal = akausal + 1;
      else 	    % ldbak(1,3) == WEG_VOM_KNOTEN
	flow = flow + 1;
      end
    end

    if(flow > 1)
      status = STATUS_KONFLIKT;
    elseif(flow == 1)
      if(akausal > 0)
	status = STATUS_HIN;
      else 	    % akausal == 0
	status = STATUS_ENDE_AUSBR;
      end
    else 	    % flow == 0
      if(akausal > 1)
	status = STATUS_ENDE_AUSBR;
      elseif(akausal == 1)
	status = STATUS_WEG;
      else 	    % akausal == 0
	status = STATUS_KONFLIKT;
      end
    end

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_tf)
    %%%%%%%%%%%%%%
    % Analyse TF %
    %%%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_tf(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    ldbak = in2;

    anzdiff = 0;

    for i=1:2
      if(ldbak(i,3) == HIN_ZUM_KNOTEN)
	status = STATUS_WEG;
      elseif(ldbak(i,3) == AKAUSAL)
      else 	    % ldbak == WEG_VOM_KNOTEN
	status = STATUS_HIN;
      end
    end
    if( ((ldbak(1,3)==HIN_ZUM_KNOTEN) & (ldbak(2,3)==WEG_VOM_KNOTEN)) ...
	  | ((ldbak(1,3)==WEG_VOM_KNOTEN) & (ldbak(2,3)==HIN_ZUM_KNOTEN)) )
      status = STATUS_ENDE_AUSBR;
    end
    if( ((ldbak(1,3)==HIN_ZUM_KNOTEN) & (ldbak(2,3)==HIN_ZUM_KNOTEN)) ...
	  | ((ldbak(1,3)==WEG_VOM_KNOTEN) & (ldbak(2,3)==WEG_VOM_KNOTEN)) )
      status = STATUS_KONFLIKT;
    end
    

    out1 = status;
    out2 = anzdiff;


  elseif(in1 == F2_analy_gy)
    %%%%%%%%%%%%%%
    % Analyse GY %
    %%%%%%%%%%%%%%
    %
    %  [status,anzdiff] = analy_gy(ldbak)
    %  
    %  status .... == Konflikt
    %		    | Ausbreitungswelle fertig
    %		    | Knoten eindeutig: Alle noch freien Bonds haben
    %					WEG_VOM_KNOTEN-Kausalit"a
    %		    | Knoten eindeutig: Alle noch freien Bons haben
    %					HIN_ZUM_KNOTEN-Kausalit"at
    %  anzdiff ... == 0 d.h. es wurde KEINE differentielle Kausalit"at
    %			     zugewiesen.
    %		    | 1 d.h. es WURDE differentielle Kausalit"at zugewiesen.
    %  ldbak ..... Liste der Bonds am Knoten
    %  

    ldbak = in2;

    anzdiff = 0;

    for i=1:2
      if(ldbak(i,3) == HIN_ZUM_KNOTEN)
	status = STATUS_HIN;
      elseif(ldbak(i,3) == AKAUSAL)
      else 	    % ldbak == WEG_VOM_KNOTEN
	status = STATUS_WEG;
      end
    end
    if( ((ldbak(1,3)==HIN_ZUM_KNOTEN) & (ldbak(2,3)==HIN_ZUM_KNOTEN)) ...
	  | ((ldbak(1,3)==WEG_VOM_KNOTEN) & (ldbak(2,3)==WEG_VOM_KNOTEN)) )
      status = STATUS_ENDE_AUSBR;
    end
    if( ((ldbak(1,3)==HIN_ZUM_KNOTEN) & (ldbak(2,3)==WEG_VOM_KNOTEN)) ...
	  | ((ldbak(1,3)==WEG_VOM_KNOTEN) & (ldbak(2,3)==HIN_ZUM_KNOTEN)) )
      status = STATUS_KONFLIKT;
    end

    out1 = status;
    out2 = anzdiff;
    
  else
    
  end 		    % End of kalikaus


elseif(action == F_rechne1)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Berechne die Zustandsraumdarstellung %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  set(H_BILD,'pointer','watch');
  drawnow;
  
  [MATRIX_A,MATRIX_B,MATRIX_C,MATRIX_D,MATRIX_E,MATRIX_F] = ...
      kalibond(F_rechne2);

  out1 = MATRIX_A;
  out2 = MATRIX_B;
  out3 = MATRIX_C;
  out4 = MATRIX_D;
  out5 = MATRIX_E;
  out6 = MATRIX_F;
  
  set(H_M_SIMUL,'enable','on');
  set(H_M_SANTW,'enable','on');
  if( (size(find(MATRIX_E),1)==0) ...
	&(size(find(MATRIX_F),1)==0) )
    set(H_M_IANTW,'enable','on');
  end
  
  set(H_BILD,'pointer','arrow');
  drawnow;

  
elseif(action == F_rechne2)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Die eigentliche Berechnungsroutine %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  %
  % Die Vektoren zusammenbauen
  % 

  dot_vec_x_i = [];
  vec_w_i = [];
  vec_w_d = [];
  dot_vec_x_d = [];
  vec_v = [];
  vec_u = [];
  vec_s = [];
  vec_r = [];
  vec_h = [];


  for b_nro=1:size(LBONDS2,1)
    % Endpunkte suchen
    % b_wnro = LBONDS2(b_nro);
    k_nro = find(LPFEIL(:,b_nro));
    if( (LELEMS(k_nro(1),2)>=TYP_1) & (LELEMS(k_nro(2),2)>=TYP_1) )
      % Ein innerer Bond
      vec_h = [vec_h; EFFORT*b_nro; FLOW*b_nro];
    else
      % Ein "au"serer Bond
      % "au"seren Knoten suchen und dessen Kausalit"at bestimmen
      if(LELEMS(k_nro(1),2)<=TYP_R)
        % erster Knoten ist der "au"sere
	k_nro_ex = k_nro(1);
      else
        k_nro_ex = k_nro(2);
      end
      kaus = LKAUS(k_nro_ex,b_nro);
      if(kaus==1)
        ausgang = FLOW;
	eingang = EFFORT;
      else
        ausgang = EFFORT;
	eingang = FLOW;
      end
      if( (LELEMS(k_nro_ex,2)==TYP_SE) | (LELEMS(k_nro_ex,2)==TYP_SF) )
        vec_u = [vec_u; eingang*b_nro];
	vec_v = [vec_v; ausgang*b_nro];
      elseif(LELEMS(k_nro_ex,2)==TYP_C)
        if(kaus==1)
	  vec_w_i = [vec_w_i; eingang*b_nro];
	  dot_vec_x_i = [dot_vec_x_i; ausgang*b_nro];
	else
	  dot_vec_x_d = [dot_vec_x_d; eingang*b_nro];
	  vec_w_d = [vec_w_d; ausgang*b_nro];
	end
      elseif(LELEMS(k_nro_ex,2)==TYP_I)
        if(kaus==-1)
	  vec_w_i = [vec_w_i; eingang*b_nro];
	  dot_vec_x_i = [dot_vec_x_i; ausgang*b_nro];
	else
	  dot_vec_x_d = [dot_vec_x_d; eingang*b_nro];
	  vec_w_d = [vec_w_d; ausgang*b_nro];
	end
      elseif(LELEMS(k_nro_ex,2)==TYP_R)
        vec_r = [vec_r; eingang*b_nro];
	vec_s = [vec_s; ausgang*b_nro];
      else
      end
    end
  end

  vec_g_a = [dot_vec_x_i; vec_w_d; vec_v; vec_s];
  vec_g_e = [vec_w_i; dot_vec_x_d; vec_u; vec_r];

  gh_a = [vec_g_a; vec_h];
  gh_e = [vec_g_e; vec_h];

  %
  % Jetzt sind die Vektoren zusammengebaut
  %
  
  % Jetzt k"onnen wir die wichtigsten Vektoren anzeigen
  
  disp(' ');
  disp('input-vector u');
  disp('--------------');
  string_u = kalibond(F_v2str,vec_u,'ef');
  disp(string_u);
  
  disp(' ');
  disp('state-vector x');
  disp('--------------');
  string_x = kalibond(F_v2str,dot_vec_x_i,'pq');
  disp(string_x);
  
  %
  % Jetzt m"ussen wir die Matrizen zusammenbauen
  %
  % Zuerst die konstitutiven Beziehungen
  %

  % Integrale Speicher

  anzahl = size(vec_w_i,1);
  if(anzahl)
    z_i = [];
    for i=1:anzahl
      b_nro = abs(vec_w_i(i));
      e_nro = find(LKAUS(:,b_nro));
      if((LELEMS(e_nro(1),2)==TYP_C)|(LELEMS(e_nro(1),2)==TYP_I))
        z_i = [z_i; 1/LELEMS(e_nro(1),3)];
      else
        z_i = [z_i; 1/LELEMS(e_nro(2),3)];
      end
    end
    Z_i = eye(size(z_i,1)).*(ones(size(z_i,1),1)*z_i');
  else
    Z_i = [0];
  end

  % Diffenentielle Speicher
  
  anzahl = size(vec_w_d,1);
  if(anzahl)
    y_d = [];
    for i=1:anzahl
      b_nro = abs(vec_w_d(i));
      e_nro = find(LKAUS(:,b_nro));
      if((LELEMS(e_nro(1),2)==TYP_C)|(LELEMS(e_nro(1),2)==TYP_I))
        y_d = [y_d; LELEMS(e_nro(1),3)];
      else
        y_d = [y_d; LELEMS(e_nro(2),3)];
      end
    end
    Y_d = eye(size(y_d,1)).*(ones(size(y_d,1),1)*y_d');
  else
    Y_d = [0];
  end

  % Verbaucher
  anzahl = size(vec_s,1);
  if(anzahl)
    d = [];
    for i=1:anzahl
      b_nro = abs(vec_s(i));
      e_nro = find(LKAUS(:,b_nro));
      if((LELEMS(e_nro(1),2)==TYP_R)|(LELEMS(e_nro(1),2)==TYP_R))
        e_nummer = e_nro(1);
      else
        e_nummer = e_nro(2);
      end
      if(LKAUS(e_nummer,b_nro)==1)
        d = [d; LELEMS(e_nummer,3)];
      else
        d = [d; 1/LELEMS(e_nummer,3)];
      end
    end
    D = eye(size(d,1)).*(ones(size(d,1),1)*d');
  else
    D = [0];
  end

  %
  % Jetzt die Verbindungsstruktur
  % 
  
  JJ = zeros(size(gh_a,1),size(gh_e,1));

  for elem=1:size(LELEMS,1)
    if( (LELEMS(elem,2)==TYP_1) ...
	  |(LELEMS(elem,2)==TYP_0) ...
	  |(LELEMS(elem,2)==TYP_TF) ...
	  |(LELEMS(elem,2)==TYP_GY) )
      aus_bonds = find(LKAUS(elem,:));
      if(LELEMS(elem,2)==TYP_1)
	for i=1:size(aus_bonds,2)
	  zeile_JJ = find(gh_a==(aus_bonds(i)*LKAUS(elem,aus_bonds(i))));
	  if(LKAUS(elem,aus_bonds(i))==FLOW)
	    ein_bond = find(LKAUS(elem,:)==EFFORT);
	    spalte_JJ = find(gh_e==(ein_bond*FLOW));
	    JJ(zeile_JJ,spalte_JJ) = 1;
	  else
	    aus_pfeil = LPFEIL(elem,aus_bonds(i));
	    ein_bonds = find(LKAUS(elem,:)==FLOW);
	    for j=1:size(ein_bonds,2)
	      spalte_JJ = find(gh_e==(ein_bonds(j)*EFFORT));
	      ein_pfeil = LPFEIL(elem,ein_bonds(j));
	      JJ(zeile_JJ,spalte_JJ) = (-1)*ein_pfeil*aus_pfeil;
	    end
	  end
	end
      elseif(LELEMS(elem,2)==TYP_0)
        for i=1:size(aus_bonds,2)
	  zeile_JJ = find(gh_a==(aus_bonds(i)*LKAUS(elem,aus_bonds(i))));
	  if(LKAUS(elem,aus_bonds(i))==EFFORT)
	    ein_bond = find(LKAUS(elem,:)==FLOW);
	    spalte_JJ = find(gh_e==(ein_bond*EFFORT));
	    JJ(zeile_JJ,spalte_JJ) = 1;
	  else
	    aus_pfeil = LPFEIL(elem,aus_bonds(i));
	    ein_bonds = find(LKAUS(elem,:)==EFFORT);
	    for j=1:size(ein_bonds,2)
	      spalte_JJ = find(gh_e==(ein_bonds(j)*FLOW));
	      ein_pfeil = LPFEIL(elem,ein_bonds(j));
	      JJ(zeile_JJ,spalte_JJ) = (-1)*ein_pfeil*aus_pfeil;
	    end
	  end
	end
      elseif(LELEMS(elem,2)==TYP_TF)
        e_aus_bond = find(LKAUS(elem,:)==EFFORT);
	f_aus_bond = find(LKAUS(elem,:)==FLOW);
	zeile_JJ_1 = find(gh_a==(e_aus_bond*EFFORT));
	zeile_JJ_2 = find(gh_a==(f_aus_bond*FLOW));
	spalte_JJ_1 = find(gh_e==(f_aus_bond*EFFORT));
	spalte_JJ_2 = find(gh_e==(e_aus_bond*FLOW));
	if(LPFEIL(elem,e_aus_bond)==-1)
	  faktor = (LELEMS(elem,3));
	else
	  faktor = 1/(LELEMS(elem,3));
	end
	JJ(zeile_JJ_1,spalte_JJ_1) = faktor;
	JJ(zeile_JJ_2,spalte_JJ_2) = faktor;
      elseif(LELEMS(elem,2)==TYP_GY)
        for i=1:2
	  zeile_JJ = find(gh_a==(aus_bonds(i)*LKAUS(elem,aus_bonds(i))));
	  spalte_JJ = find(gh_e==(aus_bonds(1+abs(i-2))*...
                                  (-1)*LKAUS(elem,aus_bonds(1+abs(i-2)))));
          if(LKAUS(elem,aus_bonds(i))==EFFORT)
	    faktor = (LELEMS(elem,3));
	  else
	    faktor = 1/(LELEMS(elem,3));
	  end
	  JJ(zeile_JJ,spalte_JJ) = faktor;
	end
      else
      end
    end
  end

  % Jetzt die JJ-Matrix partitionieren (Formel 1)

  J_11 = JJ( 1 : size(vec_g_a,1) , ...
      1 : size(vec_g_e,1) );
  
  J_12 = JJ( 1 : size(vec_g_a,1) , ...
      1+size(vec_g_e,1) : size(vec_g_e,1)+size(vec_h,1) );

  J_21 = JJ( 1+size(vec_g_e,1) : size(vec_g_e,1)+size(vec_h,1) , ...
      1 : size(vec_g_e,1) );
  
  J_22 = JJ( 1+size(vec_g_e,1) : size(vec_g_e,1)+size(vec_h,1) , ...
      1+size(vec_g_e,1) : size(vec_g_e,1)+size(vec_h,1) );
	 
  % Jetzt Formel (3) des Skriptums

  % Anm.: Ich habe die Vektoren vec_h_a und vec_h_e so zusammengebaut,
  %       da"s sie identisch sind.
  %       Daher wird die Matrix P zu einer Einheitsmatrix.
  %       Dementsprechend vereinfacht sich auch die Formel 3 des Skriptums.

  % Spezialfall: J_22 == []  ==> J_11 ist bereits die Verbindungsstruktur

  if(J_22==[])
    VS = J_11;
  else
    VS = J_11 - J_12 * inv( J_22 - eye(size(J_22)) ) * J_21;
  end
  
  % Jetzt die VS-Matrix partionieren (Formeln 8 bzw. 16)

  siz_x = size(dot_vec_x_i,1);
  siz_d = size(vec_w_d,1);
  siz_v = size(vec_v,1);
  siz_s = size(vec_s,1);

  J_xw = VS( 1:siz_x , 1:siz_x );

  J_xd = VS( 1:siz_x , 1+siz_x : siz_x+siz_d );

  J_xu = VS( 1:siz_x , 1+siz_x+siz_d : siz_x+siz_d+siz_v );

  J_xr = VS( 1:siz_x , 1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s );

  J_dw = VS( 1+siz_x : siz_x+siz_d , 1:siz_x );

  J_dd = VS( 1+siz_x : siz_x+siz_d , 1+siz_x : siz_x+siz_d );

  J_du = VS( 1+siz_x : siz_x+siz_d , 1+siz_x+siz_d : siz_x+siz_d+siz_v );

  J_dr = VS( 1+siz_x : siz_x+siz_d , ...
      1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s );

  J_vw = VS( 1+siz_x+siz_d : siz_x+siz_d+siz_v , 1:siz_x );

  J_vd = VS( 1+siz_x+siz_d : siz_x+siz_d+siz_v , 1+siz_x : siz_x+siz_d );

  J_vu = VS( 1+siz_x+siz_d : siz_x+siz_d+siz_v , ...
      1+siz_x+siz_d : siz_x+siz_d+siz_v );

  J_vr = VS( 1+siz_x+siz_d : siz_x+siz_d+siz_v , ...
      1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s );

  J_sw = VS( 1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s , 1:siz_x );

  J_sd = VS( 1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s , ...
      1+siz_x : siz_x+siz_d );

  J_su = VS( 1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s , ...
      1+siz_x+siz_d : siz_x+siz_d+siz_v );

  J_sr = VS( 1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s , ...
      1+siz_x+siz_d+siz_v : siz_x+siz_d+siz_v+siz_s );

  % So manche dieser Matrizen brauchen wir zwar nicht, und manche sind auch
  % Nullmatritzen, aber der vollst"andigkeithalber habe ich halt einmal alle
  % berechnet. Auskommentieren kann man die Programmzeilen ja immer noch.
  
  % Alle Matritzen, die leer sind mu"s ich noch ==0 setzen, damit keine
  % Ausl"oschung stattfinden kann, so wie MatLab das leider macht.
  
  if(J_xw==[])
    J_xw = [0];
  end
  if(J_xd==[])
    J_xd = [0];
  end
  if(J_xu==[])
    J_xu = [0];
  end
  if(J_xr==[])
    J_xr = [0];
  end
  if(J_dw==[])
    J_dw = [0];
  end
  if(J_dd==[])
    J_dd = [0];
  end
  if(J_du==[])
    J_du = [0];
  end
  if(J_dr==[])
    J_dr = [0];
  end
  if(J_vw==[])
    J_vw = [0];
  end
  if(J_vd==[])
    J_vd = [0];
  end
  if(J_vu==[])
    J_vu = [0];
  end
  if(J_vr==[])
    J_vr = [0];
  end
  if(J_sw==[])
    J_sw = [0];
  end
  if(J_sd==[])
    J_sd = [0];
  end
  if(J_su==[])
    J_su = [0];
  end
  if(J_sr==[])
    J_sr = [0];
  end
  
  %
  % Jetzt k"onnen wir die Zustandsgleichung berechnen
  %
  
  if(size(vec_w_d,1)==0) % keine differentielle Kausalit"aten
    if(siz_s) 	    % normal: Verbraucher vorhanden
      A = J_xw * Z_i + J_xr * D * inv(eye(size(J_sr*D))-J_sr*D) ...
	  * J_sw * Z_i;
      B = J_xu + J_xr * D * inv(eye(size(J_sr*D))-J_sr*D) * J_su;
    else 	    % Spezialfall: keine Verbraucher
      A = J_xw * Z_i;
      B = J_xu;
    end
    E = zeros(size(A,1),1);
  else 		    % mit differentiellen Kausalit"aten
    if(siz_s) 	    % normal: Verbraucher vorhanden
      K_xd = J_xr * D * inv(J_sr*D-eye(size(J_sr*D))) * J_sd * Y_d ...
	  - J_xd * Y_d;
      K_xw = J_xw * Z_i ...
	  - J_xr * D * inv(J_sr*D-eye(size(J_sr*D))) * J_sw * Z_i;
      K_xu = J_xu - J_xr * D * inv(J_sr*D-eye(size(J_sr*D))) * J_su;
    else 	    % Spezialfall: keine Verbraucher
      K_xd = J_xd * Y_d;
      K_xw = J_xw * Z_i;
      K_xu = J_xu;
    end
    A = inv(eye(size(K_xd*J_dw*Z_i))+K_xd*J_dw*Z_i) * K_xw;
    B = inv(eye(size(K_xd*J_dw*Z_i))+K_xd*J_dw*Z_i) * K_xu;
    E = -inv(eye(size(K_xd*J_dw*Z_i))+K_xd*J_dw*Z_i) * K_xd * J_du;
  end

  % Jetzt kommen die Ausgangsgr"o"sen
  
  HA_GE = inv( eye(size(J_22)) - J_22 ) * J_21;
  
  % Spezialfall: keine inneren Bonds:
  %
  % In diesem Falle gilt 
  %   J_22 == []
  % woraus sich automatisch ergibt
  %   HA_GE == []
  
  % Jetzt Unterscheidung ob differentielle Kausas
  if(size(vec_w_d,1)==0) % keine differentielle Kausalit"aten
    % Spezialfall: keine Verbraucher (siz_s==0)
    % In diesem Falle sollten sich die Matritzen
    %   S_XI,   S_U,   R_XI,   R_U
    % automatisch zu
    %    == []
    % ergeben.
    % ... Tun sie aber nicht!
    % Daher die folgende Unterscheidung
    if(siz_s)
      S_XI  = inv( eye(size(J_sr*D)) - J_sr*D ) * J_sw * Z_i;
      S_U   = inv( eye(size(J_sr*D)) - J_sr*D ) * J_su;
      R_XI  = D * S_XI;
      R_U   = D * S_U;
      V_XI  = J_vw * Z_i + J_vr * R_XI;
      V_U   = J_vu + J_vr * R_U;
    else 	    % Spezialfall: keine Verbraucher
      S_XI  = [];
      S_U   = [];
      R_XI  = [];
      R_U   = [];
      V_XI  = J_vw * Z_i;
      V_U   = J_vu;
    end
    WI_XI = Z_i;
    WI_U  = zeros(size(dot_vec_x_i,1),size(vec_u,1));
    % dotXI_XI == A;
    % dotXI_U  == B;
    U_U = eye(siz_v);
    U_XI = zeros(siz_v,siz_x);
    GA_XI = [A; V_XI; S_XI];
    GA_U  = [B; V_U ; S_U ];
    GE_XI = [WI_XI; U_XI; R_XI];
    GE_U  = [WI_U ; U_U ; R_U ];
    HA_XI = HA_GE * GE_XI;
    HA_U  = HA_GE * GE_U ;
    % Sei y == [vec_g_a ; vec_g_e ; vec_h_a]
    % ==> C,D_A
    CC = [GA_XI; GE_XI; HA_XI];
    DD = [GA_U ; GE_U ; HA_U ];
    % Da keine differentiellen Kausas :
    FF = zeros(2*size(vec_g_a,1)+size(vec_h,1),siz_v);
  else 		    % mit differentiellen Kausalit"aten
    if(siz_s)
      S_XI = inv( eye(size(J_sr*D)) - J_sr*D ) * ...
	  (J_sw*Z_i + J_sd*Y_d*J_dw*Z_i*A);
      S_U = inv( eye(size(J_sr*D)) - J_sr*D ) * ...
	  (J_su + J_sd*Y_d*J_dw*Z_i*B);
      S_DU = inv( eye(size(J_sr*D)) - J_sr*D ) * ...
	  (J_sd*Y_d*J_du + J_sd*Y_d*J_dw*Z_i*E);
      R_XI = D * S_XI;
      R_U  = D * S_U;
      R_DU = D * S_DU;
    else
      % Spezialfall: keine Verbraucher (siz_s==0)
      % In diesem Falle ergeben sich die Matritzen
      %   S_XI   S_U   S_DU   R_XI   R_U   R_DU
      % leider nicht automatisch zu
      %   == []
      % (siehe oben)
      S_XI = [];
      S_U = [];
      S_DU = [];
      R_XI = [];
      R_U  = [];
      R_DU = [];
    end
    WI_XI = Z_i;
    %    WI_U  = zeros(size(vec_w_i,1),size(vec_u));
    WI_U  = zeros(siz_x,siz_v);
    %    WI_DU = zeros(size(vec_w_i,1),size(vec_u));
    WI_DU = zeros(siz_x,siz_v);
    WD_XI = J_dw * Z_i;
    WD_U  = J_du;
    %    WD_DU = zeros(size(vec_w_d,1),size(vec_u,1));
    WD_DU = zeros(siz_d,siz_v);
    DXD_XI = Y_d*J_dw*Z_i*A;
    DXD_U  = Y_d*J_dw*Z_i*B;
    DXD_DU = Y_d*J_du + Y_d*J_dw*Z_i*E;
    if(siz_s)
      V_XI = J_vw*Z_i + J_vd*Y_d*J_dw*Z_i*A + J_vr*R_XI;
      V_U  = J_vd*Y_d*J_dw*Z_i*B + J_vu + J_vr*R_U;
      V_DU = J_vd*Y_d*(J_du+J_dw*Z_i*E) + J_vr*R_DU;
    else 	    % Spezialfall: keine Verbraucher
      V_XI = J_vw*Z_i + J_vd*Y_d*J_dw*Z_i*A;
      V_U  = J_vd*Y_d*J_dw*Z_i*B + J_vu;
      V_DU = J_vd*Y_d*(J_du+J_dw*Z_i*E);
    end
    U_XI = zeros(size(vec_u,1),size(dot_vec_x_i,1));
    U_U  = eye(size(vec_u,1));
    U_DU = zeros(size(vec_u,1),size(vec_u,1));
    GA_XI = [A; WD_XI; V_XI; S_XI];
    GA_U  = [B; WD_U;  V_U;  S_U ];
    GA_DU = [E; WD_DU; V_DU; S_DU];
    GE_XI = [WI_XI; DXD_XI; U_XI; R_XI];
    GE_U  = [WI_U;  DXD_U;  U_U;  R_U ];
    GE_DU = [WI_DU; DXD_DU; U_DU; R_DU];
    HA_XI = HA_GE * GE_XI;
    HA_U  = HA_GE * GE_U;
    HA_DU = HA_GE * GE_DU;
    % Sei y == [vec_g_a ; vec_g_e ; vec_h_a]
    % ==> C,D,F
    CC = [GA_XI; GE_XI; HA_XI];
    DD = [GA_U ; GE_U ; HA_U ];
    FF = [GA_DU; GE_DU; HA_DU];
  end

  % Jetzt die geforderten Teile der Ausgangsgleichung extrahieren
  
  C = [];
  D_A = [];
  F = [];
  % Alle m"oglichen Ausgangsgr"o"sen
  vec_y_t = [vec_g_a ; vec_g_e ; vec_h]; % t wie "`total"'
  % Den String in einen Vektor von Strings umwandeln
  av = kalibond(F_p_str2vec,OUT_VEC);
  siz_aus = size(av,1); % Wieviele Ausgangsgr"o"sen
  for i=1:siz_aus
    string = deblank(av(i,:));
    if((string(1))=='e') % Effort
      ef = EFFORT;
    elseif((string(1))=='f') % Flow
      ef = FLOW;
    else 	    % Sollte nicht vorkommen
      disp('wrong variable: ''e''|''f'' expected');
    end
    % Wirkliche Nummer des gesuchten Bonds
    wnum = str2num(string(2:size(string,2)));
    % Spaltennummer des gesuchten Bonds
    num = find(LBONDS2==wnum);
    % Zeilennummer der gesuchten Ausgangsgr"o"se im totalen Ausgangsvektor
    zeile = find(vec_y_t == (ef*num));
    C = [C; CC(zeile,:)];
    D_A = [D_A; DD(zeile,:)];
    F = [F; FF(zeile,:)];
  end

  % Abschlie"send noch den Ausgangsvektor anzeigen
  
  disp(' ');
  disp('output-vector y');
  disp('---------------');
  disp(av);
  
  disp(' ');
  
  A_str = deblank(MATR_NAM(1,:));
  B_str = deblank(MATR_NAM(2,:));
  C_str = deblank(MATR_NAM(3,:));
  D_str = deblank(MATR_NAM(4,:));
  E_str = deblank(MATR_NAM(5,:));
  F_str = deblank(MATR_NAM(6,:));
  
  AC_str = str2mat(A_str,C_str);
  BD_str = str2mat(B_str,D_str);
  EF_str = str2mat(E_str,F_str);
  
  % disp('.                 .');
  % disp('x = A*x + B*u + E*u');
  % disp(' ');
  % disp('                  .');
  % disp('y = C*x + D*u + F*u');
  % disp('-------------------');
  
  str_laenge = size(AC_str,2) ...
      + size(BD_str,2) ...
      + size(EF_str,2) ...
      + 16;

  superstring = '-';
  for i=2:str_laenge
    superstring = [superstring '-'];
  end
  disp('the state-space equations:');
  disp(superstring);
  disp(['.' blanks(str_laenge-2) '.']);
  disp(['x = ' AC_str(1,:) '*x + ' BD_str(1,:) '*u + ' EF_str(1,:) '*u']);
  disp(' ');
  disp([blanks(str_laenge-1) '.']);
  disp(['y = ' AC_str(2,:) '*x + ' BD_str(2,:) '*u + ' EF_str(2,:) '*u']);
  disp(superstring);
  
  

  % Wir sind fertig
  
  out1 = A;
  out2 = B;
  out3 = C;
  out4 = D_A;
  out5 = E;
  out6 = F;


%%  elseif(action == F_parse)
%%  str = in1;
%%  %  disp('now entering "start"');
%%  if((size(str,2))<2)
%%  disp('too short');
%%  return;
%%  end
%%  % Finde die Klammern
%%  a = findstr(str,'[');
%%  e = findstr(str,']');
%%  % Sind die Klammern gut plaziert
%%  if(size(a,2)~=1)
%%  disp('too many brackets');
%%  return;
%%  end
%%  if(size(e,2)~=1)
%%  disp('too many brackets');
%%  return;
%%  end
%%  if(~(a<e))
%%  disp('wrong brackets');
%%  return;
%%  end
%%  %  if((e-a)
%%  %  Entferne die Klammern
%%  str = str(a+1:e-1);
%%  % Diesen String in einen Vektor von Strings umwandeln
%%  out1 = kalibond(F_p_str2vec,str);
%%  % Fertig !

elseif(action == F_p_despace)
  str = in1;
  %  disp('now entering "space_weg_a"');
  if((size(str,2))<1) % String ist leer
    out1 = blanks(0);
    return;
  end
  s = findstr(str,' ');
  if((size(s,2))==(size(str,2))) % Nur Spaces
    out1 = blanks(0);
    return;
  end
  if(s==[]) 	    % keine Spaces
    out1 = str;
    return;
  end
  if(s(1)~=1) 	    % An erster Stelle des Strings kein Space
    out1 = str;
    return;
  end
  % Erstes Character des Strings ist ein Space
  str = str(2:size(str,2));
  out1 = kalibond(F_p_despace,str);
  
  
elseif(action == F_p_str2vec)
  str = in1;
  %  disp('now entering "str2vec"');
  if((size(str,2))<1) % String ist leer
    out1 = blanks(0);
    return;
  end
  % Wo sind die Semikolons
  s = findstr(str,';');
  if(s==[]) 	    % Keine Semikolons, dh. Umwandlung ist fertig
    str = deblank(str);
    out1 = kalibond(F_p_despace,str);
    return;
  else
    str1 = str(1:s(1)-1);
    str1 = deblank(str1);
    str1 = kalibond(F_p_despace,str1);
    str2 = str(s(1)+1:size(str,2));
    mat = kalibond(F_p_str2vec,str2);
    out1 = str2mat(str1,mat);
    return;
  end

  
elseif(action == F_v2str)
  v = in1;
  ef_pq = in2;
  
  zeilen = size(v,1);
  for i=1:zeilen
    nummer_s = int2str(LBONDS2(abs(v(i)),1));
    if( sign(EFFORT) == sign(v(i)) )
      ef = ef_pq(1);
    else
      ef = ef_pq(2);
    end
    if(i==1)
      string = [ef nummer_s];
    else
      string = str2mat(string,[ef nummer_s]);
    end
  end
  
  out1 = string;
  
  
elseif(action == F_print1)
  if(FILENAME~=0)
    h_title = get(gca,'Title');
    set(h_title,'String',[PATHNAME FILENAME]);
    kalibond(F_print2);
    set(h_title,'String','');
  else
    kalibond(F_print2);
  end
  
  
elseif(action == F_print2)
  if(isunix)
    if(THE_PRINTER ~= [])
      print_str = ['print -P',THE_PRINTER,';'];
      eval(print_str);
    else
      print;
    end
  else
    print -v;
  end


elseif(action == F_print_su)
  if(isunix)
    kalibond(F_message_on,['choose printer for use with ''lpr -P'' ']);
    set(H_EDIT(1),'visible','on', ...
	'string','-P');
    set(H_EDIT(2),'visible','on', ...
	'string',THE_PRINTER, ...
	'callback',['kalibond(',int2str(F_pr_cb),');']);
  else
    print -dsetup;
  end
  
  
elseif(action == F_pr_cb)
  THE_PRINTER = get(H_EDIT(2),'string');
  if(~(size(THE_PRINTER,2)))
    THE_PRINTER = [];
  end
  set(H_EDIT(1),'visible','off');
  set(H_EDIT(2),'visible','off');
  kalibond(F_message_off);
  
  
elseif(action == F_ex_eps)
  % in1 == 'mono' oder 'colour'
  if(strcmp(in1,'mono'))
    c = 0;
  elseif(strcmp(in1,'colour'))
    c = 1;
  end
  if(c)
    string = 'Export: Encapsulated PostScript';
  else
    string = 'Export: Encapsulated Colour PostScript';
  end
  [f,p] = uiputfile('*.eps',string);
  if(f~=0)
    if(c)
      eval(['print -depsc ' p f]);
    else
      eval(['print -deps ' p f]);
    end
  end

  
elseif(action == F_label)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Mache den Label f"ur die Men"us %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  if(isunix)
    wo = findstr(in1,'&');
    if(wo~=1)
      str1 = in1(1:wo-1);
    else
      str1 = setstr([]);
    end
    if(wo==size(in1,2))
      str2 = setstr([]);
    else
      str2 = in1(wo+1:size(in1,2));
    end
    out1 = [str1 str2];
  else
    out1 = in1;
  end

  
elseif(action == F_acc)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Mache den Accelerator f"ur die Men"us %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  if(isunix)
    out1 = in1;
  else
    out1 = setstr([]);
  end

  
elseif(action == F_quit1)
  %%%%%%%%%%%%%%%%%%%
  % Beende KaliBond %
  %%%%%%%%%%%%%%%%%%%

  call_back = ['kalibond(',int2str(F_quit2),');'];
  kalibond(F_if_modified,call_back);


elseif(action == F_quit2)
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  % Eigentliche Beendungsroutine %
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  delete(H_BILD);
  
  %  clear global

  clear global TYP_XX;
  clear global TYP_SE;
  clear global TYP_SF;
  clear global TYP_C;
  clear global TYP_I;
  clear global TYP_R;
  clear global TYP_1;
  clear global TYP_0;
  clear global TYP_TF;
  clear global TYP_GY;
  clear global TYP_KEINER_DA;
  clear global TRUE;
  clear global FALSE;
  clear global EFFORT;
  clear global FLOW;
  clear global WEG_VOM_KNOTEN;
  clear global AKAUSAL;
  clear global HIN_ZUM_KNOTEN;
  clear global STATUS_KONFLIKT;
  clear global STATUS_ENDE_AUSBR;
  clear global STATUS_WEG;
  clear global STATUS_HIN;
  clear global F_start;
  clear global F_elem;
  clear global F_bond;
  clear global F_matrizen;
  clear global F_outvec;
  clear global F_nelem;
  clear global F_nbond;
  clear global F_move_zwipu;
  clear global F_moved_zwipu;
  clear global F_move_elem;
  clear global F_moved_elem;
  clear global F_axis_clicked;
  clear global F_bond_clicked;
  clear global F_element_clicked;
  clear global F_zoom_in;
  clear global F_zoom_out;
  clear global F_zoom_max;
  clear global F_normiere;
  clear global F_save1;
  clear global F_save_as;
  clear global F_save2;
  clear global F_load1;
  clear global F_load2;
  clear global F_load3;
  clear global F_message_on;
  clear global F_message_off;
  clear global F_clear1;
  clear global F_clear2;
  clear global F_del_kaus;
  clear global F_modified_on;
  clear global F_modified_off;
  clear global F_if_modified;
  clear global F_edit_on;
  clear global F_edit_off;
  clear global F_button_cb;
  clear global F_menu_opt;
  clear global F_pruefe;
  clear global F_check_par;
  clear global F_par_cb;
  clear global F_ask_matrizen;
  clear global F_cancel_matrizen;
  clear global F_get_matrizen;
  clear global F_ask_ausgang;
  clear global F_cancel_ausgang;
  clear global F_get_ausgang;
  clear global F_imp_antw;
  clear global F_spr_antw;
  clear global F_kausaliere;
  clear global F_kalikaus;
  clear global F_rechne1;
  clear global F_rechne2;
%  clear global F_parse;
  clear global F_p_despace;
  clear global F_p_str2vec;
  clear global F_print1;
  clear global F_print2;
  clear global F_print_su;
  clear global F_pr_cb;
  clear global F_ex_eps;
  clear global F_quit1;
  clear global F_quit2;
  clear global F_v2str;
  clear global F_elem_num;
  clear global F_label;
  clear global F_acc;
  clear global F2_start;
  clear global F2_bgfk;
  clear global F2_scapna;
  clear global F2_vib;
  clear global F2_vtb;
  clear global F2_zuwei_se;
  clear global F2_zuwei_sf;
  clear global F2_zuwei_c;
  clear global F2_zuwei_i;
  clear global F2_zuwei_r;
  clear global F2_zuwei_ib;
  clear global F2_bsua;
  clear global F2_bak;
  clear global F2_adk;
  clear global F2_analy_sf;
  clear global F2_analy_se;
  clear global F2_analy_c;
  clear global F2_analy_i;
  clear global F2_analy_r;
  clear global F2_analy_0;
  clear global F2_analy_1;
  clear global F2_analy_tf;
  clear global F2_analy_gy;
  
  clear global LKAUS;
  clear global LPFEIL;
  clear global LELEMS;
  clear global LELEMS2;
  clear global LBONDS;
  clear global LBONDS2;
  clear global BONDLIST;
  clear global FILENAME;
  clear global PATHNAME;
  clear global MATR_NAM;
  clear global MATR_OUT;
  clear global OUT_VEC;
  clear global BILD_NAME;
  clear global H_BILD;
  clear global H_MESSAGE;
  clear global H_EDIT;
  clear global H_M_SAVE;
  clear global H_M_KAUS;
  clear global H_M_RECHNE;
  clear global H_M_SIMUL;
  clear global H_M_SANTW;
  clear global H_M_IANTW;
  clear global H_M_O_W;
  clear global LIN_ABST;
  clear global ZOOM_HIST;
  clear global DRAWMODE;
  clear global DRAWTMP;
  clear global DRAWTMP2;
  clear global DRAWLEVEL;
  clear global ZUSTAND_PRUEFE;
  clear global Z_SCHNITZER;
  clear global Z_PARAMETER;
  clear global Z_KAUSOK;
  clear global Z_KAUSVOLL;
  clear global MODIFIED;
  clear global MATRIX_A;
  clear global MATRIX_B;
  clear global MATRIX_C;
  clear global MATRIX_D;
  clear global MATRIX_E;
  clear global MATRIX_F;
  clear global THE_PRINTER;


else

  disp('*** Error: unknown action ***');

end