INSTRUCTIONS FOR A TYIPCAL INTERACTION

  To create an eBay listing page for your art you should have several
  things done beforehand. First, you need to have at least one picture
  of your art. Next, you need to have some webspace to be able to host
  that picture. Finally, you need to know all about your art (the
  artist's name, the title of the art, the size of the art, etc.). To
  invoke EZ Listing Page simply type "java -jar ezlistingpage.jar" on
  the command line and the application will start. The tabs at the top
  of the application contain different components (each one helping
  you to create your listing page). The Console tab contains a text
  interface to the underlying CE Task Engine which can be
  alternatively used to interact with the underlying task model. The
  Tasks tab contains the task tree (derived from the task model) which
  can be used to navigate through all of the inputs. The right side of
  the Tasks tab contains the text boxes, combo boxes, drop-down boxes,
  and other graphical inputs related to the current selected task. The
  Browser tab contains the current rendering of your eBay listing
  page. The HTML tab contains the current HTML of your eBay listing
  page. You can save the state of your work by going to the drop-down
  File menu and selecting Save or Save As. You can also cut, copy, and
  paste text from and to any text input field using the Edit menu.

WHAT WORKED

  EZ Listing Page has a working GUI implemented using the Jigloo
  plugin for Eclipse. EZ Listing Page has a working browser based on
  JDesktop Integration Components (JDIC). JDIC allows EZ Listing Page
  to display the host OS's native browser in a Swing GUI component.
  JDIC was successfully tested with Internet Explorer on Windows, but
  it should work equally well with all of the native browsers listed
  in the JDIC documentation. EZ Listing Page includes a console that
  displays the output of the CE Task Engine. This console also
  displays any STDERR messages. The application also includes a full
  HTML template which has been extended with custom HTML tags. These
  custom HTML tags can be gotten and set by the TemplateManipulator
  class so that the HTML template is in sync with where the user is
  in the task model. The fields within the template are sent to the
  graphical inputs as a task is visited and take precence over the
  defaults within the task model. A complete task model executed by
  the CE Task Engine has been written which touches on many of the
  recurring manual tasks that are necessary when creatig an eBay
  listing page related to art. Trilead SSH-2 will be used to transfer
  the images to the server that the user defines (currently hosted by
  WPI).

WHAT DIDN'T

  I struggled for a long time with getting the CE Task Engine to run
  alongside the EZ Listing Page. I didn't understand that I had to
  encapsulate the CE Task Engine within a Thread so that when it
  waited for input, the EZ Listing Page continued running. I followed
  the project milestones when they were well-defined, but after the
  natural language speech ouput phase there was the informal demo
  without any intermediate milestone. At that point I did not have
  enough time to create a fully working project. I would reccomend
  that the project milestones be more well-defined, with less
  emphasis placed upon the natural language input and output.
  
  The Jigloo plugin for Eclipse often caused Eclipse to hang when
  manipulating the GUI graphically. I would still reccomend that
  students who are unfamiliar with Jigloo use it, but I would use it
  in the very beginning to flush out all of the graphical aspects of
  the GUI before adding any of your code or imported libraries. Using
  guide.jar instead of including the source directly made switching to
  using the source directly more difficult. I would reccomend that the
  README.txt file explain how to modify and compile the CE Task
  Engine. Also, the JARing of the project was difficult to figure out
  when I was pressed for time.

FUTURE DIRECTIONS

  I am planning on continuing this work as time allows so that I can
  automate the creation of eBay listing pages. I have yet to integrate
  an SCP client into EZ Listing Page so that I can transfer the images
  to a webserver. I also plan on including an FTP client so that I can
  upload new images onto other servers which only support this
  interface. I plan on implementing an image module which will allow
  the user to include a non-resized image or a flipped image; the
  application would allow the user to rotate, or shrink the image as
  desired. It would also generate the appropriate HTML width and
  height tags so that the browser takes the size of the image into
  consideration when it has just downloaded the HTML. The picture
  orientation needs to be added as well so that if a piece of art is
  composed of three images, those images can be oriented left to right
  or up and down. The spacing between the pictures needs to be added
  in the form of invisible resized gif dots for cross-browser
  compatibility. The HTML template needs to be edited to use a CSS and
  several CSS need to be tested and included so that the user has
  several different styles to choose from. Currently, only native
  browsers such as Internet Explorer on Windows are supported for HTML
  rendering; however, one other refinement would be to include support
  for Firefox and other browsers on Windows.
  
  The previous refinements have little to do with the CE Task Engine.
  Future work on refinements related to the CE Task Engine and the
  task model are more interesting. Fully implementing the dynamic
  mapping of the JavaScript inputs to GUI-based components would
  reduce the amount of future work required when adding more inputs
  for the user (which translates to the user wanting to have more
  control over what gets added to the template). The task tree should
  allow the user to skip around when ordering is not a factor. In
  cases where ordering is a factor, the task tree will not allow the
  user to proceed to tasks which depend on the task they have not
  completed yet. Also, the user will not be allowed to copy the final
  HTML until the top level task is done. Saving the state of the
  system into a file would be valuable for the user since they may not
  have enough time to complete the eBay listing page in one pass. The
  entries within the task model's grounding scripts could be saved by
  the application and the task model's tasks could be supplemented
  with sufficient="true" in the postconditions so that some JavaScript
  could determine whether the task was already done or not.
  Alternatively, the state of the Java VM could be saved and
  re-instantiated.
  
  Another set of refinements deal with extension of the CE Task
  Engine. One idea is to be able to calculate the average time it
  takes the user to complete a task and to have the running average
  for each task be stored within the task itself. This would tell the
  user about how long each task takes to perform so that they could
  pick which optional tasks to perform if they are time-bound. The CE
  Task Engine could also be extended to include tasks which negatively
  or positively influence other tasks. This binding could be exploited
  in the context of the EZ Listing Page appliction for optimization of
  readability of the HTML vs. amount of content. A function which
  determines readability and one which determines content would be
  added and calculated each time a task related to each was done. The
  user would be able to optimize how much information they include vs.
  how readable the content is by looking at a dynamic control such as
  a slider bar. One more refinement to consider would be to implement
  a beginner, intermediate, and advanced set of tasks per task model.
  The user could choose the amount of detail that the UI would offer
  them. The task model should store all of these sets of tasks since
  many will overlap, and the user might want to switch to a more
  advanced set as they proceed to use the application.