How To Apportion Responsibilities And Organize Object Creation

I have a couple of objects, which I will call height and width. The latter may depend on the former and I access them through an interface:

interface Height
{
double getHeight();
}
interface Width
{
double getWidth( Height height );
}

I then have something I will call a RectangleMaker, which represents some set of rectangles that can be made. It takes a list of heights and widths and keeps track of which ones have been selected and which ones can still be made. For example, the possible heights might be 2 or 3 and the possible widths 3 or 4. It needs to determine if it can make a rectangle with a specific area and if selected to make that rectangle, disallow any other heights. So if I said, you are in charge of 2 x 3 rectangles, it could still potentially also make 2 x 4 rectangles, but 3 x 3 rectangles would no longer be an option. For the most part I think these details are irrelevant to my question, which is really about organization and assignment of responsibilities.

interface RectangleMaker
{
void setHeights( ArrayList<Height> );
void setWidths( ArrayList<Width> );
boolean isAreaAvailable( double Area );
void selectDimension( Height height, Width width );
Height listAllowedHeight();
ArrayList<Width> listAllowedWidths();
}

Now I have a new requirement. The lists of heights now need to be associated with a source, as do the widths. I should keep track of a list of RectangleMakers and pick the 'most appropriate' one for a particular area. The rule is to sort first on the height source and then on the width source and the first one able to handle the area, gets the job. So I created two enums heightSource and widthSource and had RectangleMaker implement Comparable, so I can make an ArrayList<RectangleMaker> and sort it based on the rules. Then I traverse the list and the first one that returns isAreaAvailable() true gets the job.

The final bit is that these sources also imply a specific set of Heights or Widths. How I get that set varies, it may be a fixed value or values, or might be read from a file. So in principle I could have:

ArrayList<Height> buildHeights( RectangleMaker.SOURCE source )
{
switch ( source )
{
}
}

and have a lot of specific code that builds each list by whatever method is appropriate. I still need to deal with the fact I might need additional information to build the lists. For example, one source might require a min, max and increment and another might require a file name. So I started working in the direction of more interfaces.

interface HeightList
{
ArrayList<Height> getHeights();
RectangleMaker.Source getSource();
}

I am not totally comfortable with my enum lists. They solve the sorting problem, but I am not exactly sure which class should define them. Right now they are defined by the RectangleMaker. I would need to update this class every time I added an implementation of HeightList or WidthList.

I was also thinking that since the list is built from a specific source, that source should be associated with the list. That would lead me to make this change:

interface RectangleMaker
{
void setHeights( HeightList heightList );
void setWidths( WidthList widthList );
boolean isAreaAvailable( double Area );
void selectDimension( Height height, Width width );
Height listAllowedHeight();
ArrayList<Width> listAllowedWidths();
}

It seems maybe there should be a factory in here somewhere, but this is where I am having trouble sorting out exactly who has what responsibility. I can do this sort of thing with my HeightList interface:

class SpacedHeight implements HeightList
{
int start;
int end;
int step;
ArrayList<Height> heights;
RectangleMaker.SOURCE source;

[Code] ....

Should I be thinking of putting one more layer over all of this? What complicates my thinking are two things: multiple instances may have the same source and some of these instances are dynamic. For example, two SpacedHeight instances may have different ranges, but they are both SpacedHeight and it doesn't matter which gets picked first. Exactly what SpacedHeight instances get created is determined by prompting the user for the values. If the heights come from a file, every instance would be associated with a different source and the file names would be hard-coded.

I think I want to make a HeightFactory and I think then it would make sense to move my enum definitions there. I see how I would do that if I could hard-code a specific instance of a HeightList with a specific enum. I am less clear on how to handle the case where the factory needs different parameters for different HeightList implementations.