moving files to trunk

classdef Cell < handle

    properties

        subgrid = [];

        cond = [];

        cond_text = [];

        cell_index = 0;

        parent_grid = [];

        width = 0;

        height = 0;

        grid_pb = [];

        pb_flag = 0;

        color = [];

        condition_text_width = 200;

        condition_text_height = 40;

        condition_text_x = 10;

        condition_text_y = 10;

        condition_text_offset = 20;

        grid_push_width = 30;

    end

    methods

        %% Cell

        %    

        % inputs:

        %   index:integer - cells index

        %   p_grid:Grid - Parent grid of cell

        % outputs;

        %   obj:Cell - created cell

        function obj = Cell(index, p_grid)

            obj.cell_index = index;

            obj.parent_grid = p_grid;

            obj.pb_flag = 1;

        end

        %% new_Grid

        %    

        % inputs:

        %   obj:Cell - Current Cell Object

        % outputs;

        %   

        function [] = new_Grid(obj)

            obj.subgrid = Grid(obj.cell_index,obj);

            obj.subgrid.new_Cell;

            obj.subgrid.new_Cell;

            obj.subgrid.set_rGrid(obj.parent_grid.rGrid);

            obj.pb_flag = 0;

            delete(obj.grid_pb);

            if(~isempty(obj.parent_grid.rGrid))

                obj.parent_grid.rGrid.delete_g2s(obj);

            end

        end

        %% delete_Cell

        %    deletes the current cell, will recursively delete any subgrids

        %    if they exist.

        % inputs:

        %   obj:Cell - Current Cell Object         

        % outputs;

        %   none

        function [] = delete_Cell(obj)

            if(isempty(obj.subgrid))

                delete(obj.grid_pb);

                delete(obj.cond);

                obj.cond = [];

                obj.grid_pb = [];

                delete(obj);

            else

                % delete the subgrid

                obj.subgrid.deep_delete

                if(ishghandle(obj.grid_pb))

                    delete(obj.grid_pb);

                end

                delete(obj.cond);

                obj.cond = [];

                obj.grid_pb = [];

                delete(obj);

            end

        end

        %% set_pb

        %    create the new subgrid push button handle

        % inputs:

        %   obj:Cell - Current Cell Object  

        % outputs;

        %   none

        function [] = set_pb(obj,fig,pos)

            if(obj.pb_flag == 1 && (isempty(obj.grid_pb) || ~ishghandle(obj.grid_pb)))

            obj.grid_pb = uicontrol('style','push',...

                'units','pix',...

                'string','+',...

                'HorizontalAlign','left',...

                'Parent',fig,...

                'position',pos,...   

                'callback',@(src,event)pb_call(obj,src,event));

            elseif (obj.pb_flag == 1 && ~isempty(obj.grid_pb))

                    set(obj.grid_pb,'position',pos);

                else

                end

        end

        %% pb_call

        %    callback function for the new subgrid button

        % inputs:

        %   object:Cell - Current Cell Object

        %   src:double - Source of the callback

        %   event:eventdata - Data of the eventcall

        % outputs;

        %   none

        function [] = pb_call(object,src,event)

            gui = get(src,'userdata');

            object.new_Grid;

            gui.reset_wh();

            %gui.draw_grid2(gui.Grid2);

            gui.draw_allgrids(0);

        end

        %% cal_height

        %    calculates the height in number of cells of the current cell.

        %    if the cell does not have a subgrid the height will be 1, else

        %    it will be the height of the subgrid.

        % inputs:

        %   obj:Cell - Current Cell Object 

        %   edit:boolean - 0 when not in edit mode, 1 in edit mode

        % outputs;

        %   h:double - height in number of cells

        function h = cal_height(obj,edit)

            h = 0;

            if (isempty(obj.subgrid))

                h = 1;

            else

                for i=1:size(obj.subgrid.cells,2)

                    h = h + cal_height(obj.subgrid.cells(i),edit);

                end

                % edit button is half a cell high, if in edit mode increase

                % by 0.5

                if (edit == 1)

                    h = h + 0.5;

                end

            end

        end

        %% get_pos

        %    Returns the position of the edit box for the cell

        % inputs:

        %   obj:Cell - Current Cell Object  

        % outputs;

        %   pos:[double double double double] - position of the cell

        function pos = get_pos(obj)

            if (~isempty(obj.cond))

                pos = get(obj.cond,'position');

            end

        end

        %% set_pos

        %    allows accessor to set the position of the edit box for the

        %    cell.

        % inputs:

        %   obj:Cell - Current Cell Object 

        %   pos:[double double double double] - the new position of the

        %   cell

        % outputs;

        %   none

        function [] = set_pos(obj,pos)

            if (~isempty(obj.cond))

                set(obj.cond,'position',pos);

            end

        end

        %% flag_cell

        % mode

        %   0 - normal

        %   1 - red (error/false)

        %   2 - green (ok/true)

        function [] = flag_cell(obj,mode)

            if (isempty(obj.color))

                obj.color = get(obj.cond,'BackgroundColor');

            end

            if (mode == 0)

                set(obj.cond,'BackgroundColor',obj.color);

            elseif (mode == 1)

                set(obj.cond,'BackgroundColor',[0.92 0.65 0.65])

            elseif (mode == 2)

                set(obj.cond,'BackgroundColor',[0.03 1.0 0.32]);

            end

        end

    end

end

classdef Grid < handle

    properties

        parent_cell = [];

        parent_grid = [];

        cells = [];

        split_pb = [];

        num_cells = 0;

        grid_index = 0;

        rGrid = [];

        new_cell_pb = [];

        delete_cell_pb = [];

    end

    methods

        %% Grid

        %    constructor

        % inputs:

        %   index:integer - Grid's index

        %   p_cell:Cell - Parent cell

        % outputs:

        %   n:Cell - created cell

        function n = Grid(index,p_cell)

            n.grid_index = index;

            n.parent_cell = p_cell;

        end

        %% set_rGrid

        %    set the reference to the Results grid

        % inputs:

        %   obj:Grid - current Grid object

        %   r:RGrid - result Grid

        % outputs:

        %   none

        function [] = set_rGrid(obj,r)

            obj.rGrid = r;

        end

        %% new_Cell

        %    creates a new cell in the current grid.

        % inputs:

        %   obj:Grid - current Grid object

        % outputs:

        %   none

        function [] = new_Cell(obj)

           cell = Cell(obj.num_cells+1,obj);

            obj.num_cells = obj.num_cells + 1;

            obj.cells = [obj.cells cell];

            % refresh the rGrid so that a new results cell is created

            if(~isempty(obj.rGrid))

                obj.rGrid.refresh;

            end

        end

        %% delete_Cell

        %    deletes the last cell in the grid, also deletes an associated

        %    new grid push button,

        %    TODO, need to implement the case where last cell is deleted.

        % inputs:

        %   obj:Grid - current Grid object

        % outputs

        %   none

        function [] = delete_Cell(obj)

           last_cell = obj.num_cells;

           obj.rGrid.delete_g2s(obj.cells(end));

           delete(obj.cells(end).cond)

           obj.cells(end).cond = []

           delete(obj.cells(end).grid_pb);

           obj.cells(end).grid_pb = []

           delete(obj.cells(end))

           obj.cells(end) = [];

           if(~isempty(obj.rGrid))

                obj.rGrid.refresh;

            end

        end

        %% max_width

        %    determines the maximum width from a current grid, the maximum

        %    widht represents the number of levels of subgrids from a given

        %    grid.

        % inputs:

        %   obj:Grid - current Grid object

        % outputs:

        %   m:integer - value representing the maximum width from the

        %   current grid.

        function m = max_width(obj,width)

            temp = []

            for i=1:size(obj.cells,2)

                if (~isempty(obj.cells(i).subgrid))

                    temp = [temp obj.cells(i).subgrid.max_width(width+1)];

                else

                    temp = [temp width];

                end

            end

            m = max(temp);

        end

        %% set_widths

        %    sets the widths for each of the cells and subcells in a grid.

        %    the width of a cell is equal to the max width of the previous

        %    level - 1 if the cell has no subgrids, or 1 if the cell has a

        %    subgrid.

        % inputs:

        %   obj:Grid - current Grid object

        % outputs:

        %   none

        function [] = set_widths(obj,max_width)

            for i=1:size(obj.cells,2)

                if (~isempty(obj.cells(i).subgrid))

                    obj.cells(i).subgrid.set_widths(max_width-1);

                    obj.cells(i).width = 1;   

                else

                    obj.cells(i).width = max_width;

                end                

            end

        end

        %% set_heights

        %    sets the heights for each of the cells and subcells of a grid,

        %    uses the cells cal_height method to determine what the heights

        %    should be.

        % inputs:

        %   obj:Grid - current Grid object

        %   edit:boolean - current value of the edit toggle.

        % outputs:

        %   none

        function [] = set_heights(obj,edit)

            for i = 1:size(obj.cells,2)

                if (~isempty(obj.cells(i).subgrid))

                    obj.cells(i).subgrid.set_heights(edit);

                end

                obj.cells(i).height = obj.cells(i).cal_height(edit);

            end

        end

        %% set_pb

        %    create the new cell push button

        % inputs:

        %   obj:Grid - current Grid object

        % outputs:

        %   none

        function [] = set_pb(obj,fig,pos)

            if(isempty(obj.new_cell_pb) || ~ishghandle(obj.new_cell_pb))

            obj.new_cell_pb = uicontrol('style','push',...

                'units','pix',...

                'string','new',...

                'HorizontalAlign','left',...

                'Parent',fig,...

                'position',pos,...

                'callback',@(src,event)pb_new_call(obj,src,event));

            else

                set(obj.new_cell_pb,'position',pos);

            end

        end

        %% set_delete_pb

        %    create the delete cell push button

        % inputs:

        %   obj:Grid - current Grid object

        % outputs:

        %   none

        function [] = set_delete_pb(obj,fig,pos)

            if(isempty(obj.delete_cell_pb) || ~ishghandle(obj.delete_cell_pb))

            obj.delete_cell_pb = uicontrol('style','push',...

                'units','pix',...

                'string','delete',...

                'HorizontalAlign','left',...

                'Parent',fig,...

                'position',pos,...

                'callback',@(src,event)pb_delete_call(obj,src,event));

            else

                set(obj.delete_cell_pb,'position',pos);

            end

        end

        %% pb_new_call

        %    call back function for the new cell push button. When button

        %    is pressed a new cell object is created in the current grid 

        %    and the table is redrawn

        % inputs:

        %   obj:Grid - current Grid object

        %   src:double - source of the callback calling

        %   event:eventdata - event that triggered the callback

        % outputs:

        %   none

        function [] = pb_new_call(obj,src,event)

           gui = get(src,'userdata');

            obj.new_Cell;

            gui.reset_wh();

            %gui.draw_grid2(gui.Grid2);

            gui.draw_allgrids(0);

            if size(obj.cells,2) > 1

                set(obj.delete_cell_pb,'Enable','on');

            else

                set(obj.delete_cell_pb,'Enable','off');

            end

        end

        %% pb_delete_call

        %    callback function for when user clicks on the delete cell

        %    button.

        % inputs:

        %   obj:Grid - current Grid object

        %   src:double - source of the callback calling

        %   event:eventdata - event that triggered the callback

        % outputs:

        %   none

         function [] = pb_delete_call(obj,src,event)

           gui = get(src,'userdata');

           deleted_cell = obj.cells(end)

            % button could be pressed in the left or top grid so we need to

            % try to remove the result cell associated with either case.

            obj.rGrid.delete_g2s(deleted_cell);

            obj.rGrid.delete_g1s(deleted_cell);

            deleted_cell.delete_Cell

            obj.cells(end) = [];

           if size(obj.cells,2) == 0

             if (~isempty(obj.parent_cell))

                obj.parent_cell.subgrid = [];

                obj.parent_cell.pb_flag = 1;

                delete(obj.new_cell_pb);

                delete(obj.delete_cell_pb);

                obj.rGrid.refresh;

             end

           end

           if size(obj.cells,2) == 1 && isempty(obj.parent_cell)

            set(obj.delete_cell_pb,'Enable','off');

           end

            gui.reset_wh();

            gui.draw_allgrids(0);

         end

         %% deep_delete

         %    deletes an entire grid as well as all the subgrids associated

         %    with it.

         % inputs:

         %   obj:Grid - current Grid object

         % outputs:

         %   none

         function [] = deep_delete(obj)

             % loop through each cell and delete the associated result

             % cells and call delete_Cell on each of the cells, which will

             % then call deep_delete on its subgrids.

             for i=size(obj.cells,2):-1:1

                 obj.rGrid.delete_g2s(obj.cells(i));

                 obj.cells(i).delete_Cell;

                 obj.cells(i) = [];

             end

             delete(obj.new_cell_pb)

             delete(obj.delete_cell_pb)

             obj.new_cell_pb = [];

             obj.delete_cell_pb = [];

         end

    end

end

classdef RCell < handle

    %UNTITLED2 Summary of this class goes here

    %   Detailed explanation goes here

    properties

        Cell1 = [];

        Cell2 = [];

        result = [];

        result_text = [];

        color = [];

    end

    methods

        %% RCell

        %    Constructor

        % inputs:

        %   cell1:Cell - cell reference in top grid

        %   cell2:Cell - Cell reference in left grid

        % outputs;

        %   n:RCell - created RCell

        function n = RCell(cell1,cell2)

            n.Cell1 = cell1;

            n.Cell2 = cell2;

        end

        %% flag_cell

        % mode

        %   0 - normal

        %   1 - red (error/false)

        %   2 - green (ok/true)

        function [] = flag_cell(obj,mode)

            if (isempty(obj.color))

                obj.color = get(obj.result,'BackgroundColor');

            end

            if (mode == 0)

                set(obj.result,'BackgroundColor',obj.color);

            elseif (mode == 1)

                set(obj.result,'BackgroundColor',[0.92 0.65 0.65])

            elseif (mode == 2)

                set(obj.result,'BackgroundColor',[0.03 1.0 0.32]);

            end

        end

    end

end