GUI.m

                                    else
                                        depth = depth + 1;
                                        space = [];
                                        for k=1:depth
                                            space = [space sprintf('  ')];
                                        end
                                        code = [code sprintf('%smissing!!!\n',space)]
                                        depth = depth - 1;
                                        space = [];
                                        for k=1:depth
                                            space = [space sprintf('  ')];
                                        end
                                    end
                                end
                                code = [code sprintf('%send\n',space)];
                            end
                        end
                        depth = depth - 1;
                        space = [];
                        for k=1:depth
                            space = [space sprintf('  ')];
                        end
                        
                    end
                end
                code = [code sprintf('%send\n',space)];
                
            end
            
            
            
        end
      
             
        function [] = look_for_blanks(obj,grid)
            
        end
        
        %% save_conditions
        % this function is used to save the strings that are in each of the
        % condition edit boxes string field. We do this because when we
        % want to reopen the gui we want to repopulate these fields but the
        % handles to the edit boxes will disappear when we close the gui,
        % so we need to save the strings into variables in each of the Cell
        % objects. function is recursive.
        % inputs:
        %   obj:GUI - current GUI object
        %   grid:Grid - grid to be saved.
        % outputs;
        %   none
        function [] = save_conditions(obj,grid)
            for i=1:size(grid.cells,2)
                if ~isempty(grid.cells(i).subgrid)
                    obj.save_conditions(grid.cells(i).subgrid);
                end
                grid.cells(i).cond_text = get(grid.cells(i).cond,'String');
            end
        end
        
        %% save_results
        %   Save as save_conditions but for the results grid, since not a
        %   recursive datatype we do not need to recurse.
        % inputs:
        %   obj:GUI - current GUI object
        %   grid:RGrid - results grid to be saved.
        % outputs;
        %   none
        function [] = save_results(obj,grid)
            for i=1:size(grid.Cells,2)
                grid.Cells(i).result_text = get(grid.Cells(i).result,'String');
            end
        end
        
        %% close_fig
        %    callback function that is called whenever the close button is
        %    pressed. 
        % inputs:
        %   object - current GUI object
        %   src - source of the callback calling
        %   event - event that triggered the callback
        % outputs;
        %   none
        function [] = close_fig(object,src,event)
            % save the relavent edit boxes to respective variables
            save_conditions(object,object.Grid2);
            save_conditions(object,object.Grid1);
            save_results(object,object.Grid0);
            object.function_name_text = get(object.function_name_control,'String')
            object.function_inputs_text = get(object.function_inputs_control,'String')
            
            % delete the figure, closing the window.
            delete(object.fig);
            % remove reference to the old figure.
            object.fig = [];
        end
        
        %% edit_tog_call
        %    callback function for when the edit button is clicked. when
        %    edit is toggled we want to redraw the table with the edit
        %    button visible or not visible
        % inputs:
        %   object - current GUI object
        %   src - source of the callback calling
        %   event - event that triggered the callback
        % outputs;
        %   none
        function [] = edit_tog_call(object,src,event)
            % save the value of the edit toggle
            value = get(src,'Value');
            object.edit = value;
            % reset the widths and heights of the grid then redraw all the
            % grids.
            object.reset_wh;
            object.draw_allgrids(0);
            
        end
        
        %% set_grid
        %    allows accessing objects to set the grid variables to the
        %    inputed objects
        % inputs:
        %   obj:GUI - current GUI object
        %   grid2:Grid - Grid on the left
        %   grid1:Grid - Grid on the top
        %   grid0:RGrid - Results grid
        % outputs;
        %   none
        function [] = set_grid(obj,grid2,grid1,grid0)
            obj.Grid2 = grid2;
            obj.Grid1 = grid1;
            obj.Grid0 = grid0;
        end
        
        %% draw_grid2
        %    Draws the grid on the left onto the figure.
        % inputs:
        %   obj:GUI - current GUI object
        %   grid:Grid - grid to be drawn, should be grid on left.
        %   load:boolean - 0 if grid is being refreshed, 1 if grid is being
        %       loaded for the firs time.
        % outputs;
        %   none
        function [] = draw_grid2(obj,grid,load)
            if (~isempty(grid))
                % generate a random pastel colour for the background, each
                % grid has a different colour to help with readability
                grid_color = [0.9+0.1*rand(1) 0.9+0.1*rand(1) 0.9+0.1*rand(1)];
                for i=1:size(grid.cells,2)
                    % check if the grid is the root grid
                    if (~isempty(grid.parent_cell))
                        % grid is not the root grid location is derived
                        % from its parent.
                        parent_pos = grid.parent_cell.get_pos;
                        if i == 1
                            % if we are at the first cell, location is the
                            % same as the parent but shifted to the right
                            % by one cell
                            pos(3) = grid.cells(i).width * grid.cells(i).condition_text_width;
                            pos(4) = grid.cells(i).height * grid.cells(i).condition_text_height;
                            pos(1) = parent_pos(1) + parent_pos(3);
                            pos(2) = parent_pos(2) + parent_pos(4) - pos(4);
                        else
                            % if we are not at the first cell, location is
                            % the same as the previous cell but we shift
                            % down by one cell
                            prev_pos = grid.cells(i-1).get_pos;
                            pos(3) = grid.cells(i).width * grid.cells(i).condition_text_width;
                            pos(4) = grid.cells(i).height * grid.cells(i).condition_text_height;
                            pos(1) = parent_pos(1) + parent_pos(3);
                            pos(2) = prev_pos(2) - pos(4);
                            grid_color = grid.cells(i-1).color;
                            
                        end
                    else
                        % grid is the root grid.
                        % position of the first cell is based on
                        % condition_text_x, and condition_text_y, as well
                        % as the height of the figure and header.
                        figpos = get(obj.fig,'position');
                        pos = [grid.cells(i).condition_text_x figpos(4)-obj.header_height-grid.cells(i).condition_text_y grid.cells(i).condition_text_width grid.cells(i).condition_text_height];
                        if i == 1
                            pos(1) = pos(1);
                            pos(4) = grid.cells(i).height * grid.cells(i).condition_text_height;

                            pos(2) = pos(2)-pos(4)-grid.cells(i).condition_text_height-grid.cells(i).condition_text_offset;
                            pos(3) = grid.cells(i).width * grid.cells(i).condition_text_width;
                            pos(4) = grid.cells(i).height * grid.cells(i).condition_text_height;
                        else
                            prev_pos = grid.cells(i-1).get_pos;
                            pos(3) = grid.cells(i).width * grid.cells(i).condition_text_width;
                            pos(4) = grid.cells(i).height * grid.cells(i).condition_text_height;
                            pos(1) = pos(1);
                            pos(2) = prev_pos(2) - pos(4);
                            grid_color = grid.cells(i-1).color;
                        end
                    end
                    
                    
                    % if the edit box does not exist, ie. it is just being
                    % created or we are loading the figure
                    if (isempty(grid.cells(i).cond) || load == 1)
                        % create the new edit box
                        grid.cells(i).cond = obj.create_std_text(obj.fig,pos);
                        % if cell is the first in the grid use the new
                        % colour, else take the colour of the previous cell
                        % in the grid.
                        if(i==1)
                        set(grid.cells(i).cond,'BackgroundColor',grid_color);
                        else
                            set(grid.cells(i).cond,'BackgroundColor',get(grid.cells(i-1).cond,'BackgroundColor'))
                        end
                        grid.cells(i).color = grid_color;
                        % if we are loading the cell set the string of the
                        % edit box to be the value that we saved as a
                        % result of calling save_conditions
                        if (load == 1)
                            set(grid.cells(i).cond,'String',grid.cells(i).cond_text);
                        end
                    else
                        % if the edit box is already created change is
                        % position to newly determined position.
                        grid.cells(i).set_pos(pos);
                    end
                    % determine if we want to draw the new subgrid buttons,
                    % which is located to the right of each of the leaf
                    % cells.
                    if(grid.cells(i).pb_flag == 1 && obj.edit == 1)
                        pb_pos = pos;
                        pb_pos(1) = pos(1)+pos(3);
                        pb_pos(3) = grid.cells(i).grid_push_width;
                        if (ishghandle(grid.cells(i).grid_pb))
                            set(grid.cells(i).grid_pb,'Visible','on');
                        end
                        grid.cells(i).set_pb(obj.fig,pb_pos)
                        set(grid.cells(i).grid_pb,'UserData',obj);
                    elseif(grid.cells(i).pb_flag == 1 && obj.edit ~= 1)
                        if (ishghandle(grid.cells(i).grid_pb))
                        set(grid.cells(i).grid_pb,'Visible','off')
                        end
                    end
                    
                    delete_pb_pos = []
                   
                    
                    % detemine if we want to draw the new cell buttons,
                    % which are located at the botton of the set of cells.
                    if (i == size(grid.cells,2) && obj.edit == 1)
                        new_pb_pos = pos;
                        new_pb_pos(4) = grid.cells(i).condition_text_height/2;
                        new_pb_pos(3) = pos(3)/2;
                        new_pb_pos(2) = pos(2) - new_pb_pos(4);
                        if (ishghandle(grid.new_cell_pb))
                            set(grid.new_cell_pb,'Visible','on');
                        end
                        grid.set_pb(obj.fig,new_pb_pos);
                        set(grid.new_cell_pb,'userdata',obj);
                        
                        
                        delete_pb_pos = new_pb_pos;
                        delete_pb_pos(1) = new_pb_pos(1) + new_pb_pos(3);
                        if (ishghandle(grid.delete_cell_pb))
                            set(grid.delete_cell_pb,'Visible','on');
                        end
                        grid.set_delete_pb(obj.fig,delete_pb_pos);
                        set(grid.delete_cell_pb,'userdata',obj);
                    elseif (i == size(grid.cells,2) && obj.edit ~= 1)

                        if (ishghandle(grid.new_cell_pb))
                            set(grid.new_cell_pb,'Visible','off');
                        end

                        if (ishghandle(grid.delete_cell_pb))
                            set(grid.delete_cell_pb,'Visible','off');
                        end
                    end
                    
                    
                    
                    % recursively draw the subgrid of the cell if it
                    % exists.
                    obj.draw_grid2(grid.cells(i).subgrid,load);
                end
                
       
            end
        end
        
        %% reset_wh
        %    function will call the set_widths and set_heights methods on
        %    the left grid in the table. The height and width values are
        %    used to draw the grid.
        % inputs:
        %   obj:GUI - current GUI object
        % outputs;
        %   none
        function [] = reset_wh(obj)
            width = obj.Grid2.max_width(1);
            obj.Grid2.set_widths(width);
            obj.Grid2.set_heights(obj.edit);
        end
        
        %% draw_grid1
        %     Draws the grid on the top onto the figure. the current
        %     assumption is that the top grid does not have any subgrids, 
        % inputs:
        %   obj:GUI - current GUI object
        %   grid:Grid - grid to be drawn, should be grid on top.
        %   load:boolean - 0 if grid is being refreshed, 1 if grid is being
        %       loaded for the firs time.
        % outputs;
        %   none
        function [] = draw_grid1(obj,grid,load)
            % assumption grid 1 has no subgrids
            pos = [];
            for i=1:size(grid.cells,2)
                % if we are in edit mode we need to shift over the cells to
                % accomidate for the new grid buttons in the left grid.
                if(obj.edit == 1)
                    pb_space = grid.cells(i).grid_push_width;
                else
                    pb_space = 0;
                end
                figpos = get(obj.fig,'position');

                % check if grid2 is empty, currently grid 2 will never be
                % empty, may change in future though.
                if (isempty(obj.Grid2))      
                    pos = [grid.cells(i).condition_text_x grid.cells(i).condition_text_y grid.cells(i).condition_text_width grid.cells(i).condition_text_height];
                else
                    pos = [grid.cells(i).condition_text_x+grid.cells(i).condition_text_width*obj.Grid2.max_width(1) figpos(4)-obj.header_height-grid.cells(i).condition_text_y-grid.cells(i).condition_text_height grid.cells(i).condition_text_width grid.cells(i).condition_text_height];
                end
                % set the x coordinate of the cell
                pos(1) = pos(1) + (i-1)*grid.cells(i).condition_text_width + grid.cells(i).condition_text_offset + pb_space;
                % if the edit box does not exist create it, if it does
                % adjust it's position.
                if (isempty(grid.cells(i).cond) || load == 1)
                    grid.cells(i).cond = obj.create_std_text(obj.fig,pos);
                    if (load == 1)
                        set(grid.cells(i).cond,'String',grid.cells(i).cond_text); 
                    end
                else
                    grid.cells(i).set_pos(pos);
                end
            end
            % if we are in edit mode, draw the new and delete buttons at
            % the right of the last cell
            if( obj.edit == 1)
                pos(1) = pos(1) + pos(3);
                pos(2) = pos(2) + 20;
                pos(4) = 20;
                pos(3) = 60;
                grid.set_pb(obj.fig,pos);
                pos(2) = pos(2) - 20;
                
                grid.set_delete_pb(obj.fig,pos);
                set(grid.delete_cell_pb,'userdata',obj);
                set(grid.new_cell_pb,'userdata',obj);
            else
                delete(grid.new_cell_pb)
                grid.new_cell_pb = [];
                delete(grid.delete_cell_pb)
                grid.delete_cell_pb = [];
            end
            if obj.edit ==1 || load == 1
                fig_pos = get(obj.fig,'position')
                if(pos(1)+pos(3)>fig_pos(3))
                    fig_pos(3) = pos(1)+pos(3)
                    set(obj.fig,'position',fig_pos);
                elseif (pos(1) + pos(3)<obj.fig_width)
                    fig_pos(3) = obj.fig_width
                    set(obj.fig,'position',fig_pos);
                elseif (pos(1) + pos(3)<fig_pos(3) && pos(1) +pos(3) >obj.fig_width)
                    fig_pos(3) = pos(1)+pos(3)
                    set(obj.fig,'position',fig_pos);
                end
            end
        end
        
        %% draw_grid0
        %   function will draw the output grid onto the figure  
        % inputs:
        %   obj:GUI - current GUI object
        %   grid:Grid - grid to be drawn, should be grid on left.
        %   load:boolean - 0 if grid is being refreshed, 1 if grid is being
        %       loaded for the firs time.
        % outputs;
        %   none
        function [] = draw_grid0(obj,grid,load)
            % ensure that the results grid is up to date.
            grid.refresh();
            for i=1:size(grid.Cells,2)
                % get the x coordinate from the associated top grid cell,
                % get the y coordinate from the associated right grid cell.
                pos1 = grid.Cells(i).Cell1.get_pos;
                pos2 = grid.Cells(i).Cell2.get_pos;
                pos = [0 0 0 0];
                pos(1) = pos1(1);
                pos(2) = pos2(2);
                pos(3) = pos1(3);
                pos(4) = pos2(4);
                if isempty(grid.Cells(i).result) || load == 1
                    
                    grid.Cells(i).result = obj.create_std_text(obj.fig,pos);
                    % if we are loading the cell, try to restore the text
                    % that was saved using save_results.
                    if load == 1
                        set(grid.Cells(i).result,'String',grid.Cells(i).result_text);
                    end
                else
                    set(grid.Cells(i).result,'position',pos);
                end
            end
        end
        
        %% draw_allgrids
        %    function will call the draw methods for each of the 3 grids.
        % inputs:
        %   obj:GUI - current GUI object
        %   load:boolean - 0 if grid is being refreshed, 1 if grid is being
        %       loaded for the firs time.
        % outputs;
        %   none
        function [] = draw_allgrids(obj,load)
            obj.draw_grid2(obj.Grid2,load);
            obj.draw_grid1(obj.Grid1,load);
            
            obj.draw_grid0(obj.Grid0,load);
        end
        
        %% evaluate_counter
        function [] = evaluate_counter(obj,counter)
            
            problem = obj.evaluate_counter_grid(obj.Grid2, counter)
            if(~problem)
                obj.evaluate_counter_grid(obj.Grid1, counter)
            end
        end
        
        %% evaluate_counter_grid
        % counter has form 'x=0\ny=2'
        function problem = evaluate_counter_grid(obj,grid,counter)
        % split the list of inputs to get inputs seperatly
           inputs = get(obj.function_inputs_control,'String');
           inputs = regexp(inputs,',','split');
           check_string = [];
           
           % keep track of the number of condtitions that evaulate to true
           true_conds = 0;
           sub_problem = 0;
           problem = 0;
           empty_cell = 0;
           % initialize inputs to zero
           % functions are assumed to be total, so 0 is just for 
           % convienence
           for i=1:size(inputs,2)
                % set to zero
                check_string = [check_string sprintf('%s=0;\n',char(inputs(i)))];
           end
           
           check_string = [check_string counter sprintf('\n')];
           for i=1:size(grid.cells,2)
                condition_string = get(grid.cells(i).cond,'string');
                if(~isempty(condition_string))
                   
                    eval([check_string  'result =(' char(condition_string) ')'])
                    if(result == 0)
                        grid.cells(i).flag_cell(1);
                    else
                        true_conds = true_conds + 1;
                        
                        grid.cells(i).flag_cell(2);
                    end
                else
                    empty_cell = 1;
                end
           end
           
           if (true_conds == 1)
               for i=1:size(grid.cells,2)
                    condition_string = get(grid.cells(i).cond,'string');
                    if(~isempty(condition_string))

                        eval([check_string  'result =(' char(condition_string) ')'])
                        if(result == 0)
                            grid.cells(i).flag_cell(1);
                        else

                            if (~isempty(grid.cells(i).subgrid))
                                sub_problem = obj.evaluate_counter_grid(grid.cells(i).subgrid,counter);
                            end
                            grid.cells(i).flag_cell(2);
                        end
                    else
                        empty_cell = 1;
                    end
               end
           end
           
           
           if (true_conds ~= 1 || sub_problem == 1)
               problem = 1
           end
           
           if (empty_cell)
               problem = 0
           end
           
        end
       
        
        %% create_std_text
        %   function will create an edit text box used for conditons and
        %   results. we want these to be consistent so its easier for it to
        %   be in one function.
        % inputs:
        %   obj:GUI - current GUI object
        %   Parent:double - handle to parent figure
        %   position:[double double double double] - position to place edit
        %       box in.
        % outputs;
        %   control:double - handle pointing to newly created uicontrol
        function control = create_std_text(obj, Parent, position)
            control = uicontrol('style','edit',...
                'Parent',Parent,...
                'units','pix',...
                'position',position,...
                'min',0,'max',1,...  % This is the key to multiline edits.
                'string',{''},...
                'Max',2.0,...
                'Clipping','on',...
                'fontweight','bold',...
                'BackgroundColor',[1 1 1],...
                'horizontalalign','center',...
                'fontsize',11);
            
            
        end
        
        
    end
end