Latest revision as of 22:03, 18 June 2006

general TODO

Sanakan 02:40, 18 June 2006 (CEST)

• revise code hiding/showing

-> assigned to: panarium, exception, sanakan

• testing!!!!!

-> assigned to: everyone

salmanasar 13:15, 9 May 2006 (CEST)

I suggest, that every change in the classes is reported with a little comment (perhaps via the mailinglist), so that those of us who do part 3 and 4 are able to support the coders, as sanakan proposed.

working title of the project

A few ideas:

• Folding -> falten -> eiffel-origami
• FEES : Folding editor for Eiffel Studio
• hidden beauty project
• HYCs : Hide your code
• Folding Fields
• Heilige Dreifaltigkeit

any comments from team members?

Sanakan 22:02, 19 April 2006 (CEST)

Bayt I really like origamiE :-)

Bru origamiE is cool. Another propasal: FEdEX (Folding: an Editor EXtension or an Folding for Editors: an Eiffel eXtension)

--Salmanasar 08:02, 19 June 2006 (CEST) just for fun, since I was frustrated of compiling Eiffel:

Testing/Checking

--Salmanasar 12:35, 13 June 2006 (CEST)

I wrote a little Eiffel-program with which you can check if our folding-editor works:

indexing
	description	: "System's root class, Class to test if folding editor works"
	author: "salmanasar"
	date: "11.06.2006"
	revision: "1.1"

class
	ROOT_CLASS

create
	make

feature -- Initialization

	make is
			-- Creation procedure.
		local
			option : INTEGER
			number : INTEGER
		do
			-- Print some welcome text.
			io.put_string("Enter your option: {1,2,3}")
			io.new_line
			io.put_string("=========================")
			io.new_line
			io.read_integer
			option := io.last_integer
			io.new_line
			io.new_line
			io.put_string("Enter a number between 1 and 20")
			io.new_line
			io.put_string("===============================")
			io.new_line
			io.read_integer
			number := io.last_integer
			-- if to be folded
			if (number > 0) and (number < 21) then
				-- inspect to be folded
	 			inspect option
  				when 1 then looping(number)
  				when 2 then casedecision(number)
  				when 3 then inspecting_thing(number)
  					
  				else io.put_string("no such option!!")
  				end
			end
			 
			
			
		end
		
feature -- cases
	
	looping(n: INTEGER) is
			-- feature with 2 loops, 1 if-then-else printing a checkered triangle
		local
			i, j, star: INTEGER
		do
			from
				i := 1
				star := 1
			until
				i > n
			loop
				from 
				 	j := 1
				until
					j > i
				loop
					if j \\ 2 = star then
						io.put_character (' ')
					else 
					 	io.put_character ('*')
					end
					j := j + 1
				end
				star := 1 - star
				i := i + 1
				io.put_new_line
			end 
		end
		
	
	casedecision(n:INTEGER) is
			--  feature with if then elseif
		do 
			-- if to be folded
			if n > 10
   				then io.put_string ("What a huge number!!!")
   			elseif n >5 
   				then io.put_string ("What a little number!!!")
   			else io.put_string ("What a tiny number!!!")
			end
		end
		
	inspecting_thing(n:INTEGER) is
			--  feature with weird inspecting thing
		do 
				-- inspect to be folded
	 			inspect n
  				when 1 then io.put_string ("one")
  				when 2 then io.put_string ("two")
  				when 3 then io.put_string ("three")
  				when 4 then io.put_string ("four")
  				when 5 then io.put_string ("five")
  				when 6 then io.put_string ("six")
  				when 7 then io.put_string ("seven")
  				when 8 then io.put_string ("eight")
  				else io.put_string ("too big")
  				end
		end



end -- class ROOT_CLASS

ADT: general Talk

Exception 14:45, 4 May 2006 (CEST)
I think we need another data type / class that specifies where folding is possible and whether it's folded or not. I propose the name EV_FOLDING_AREA.

it should have the following functions:
create: -> EV_FOLDING_AREA
the area goes from this character on.
from: EV_FOLDING_AREA -> INTEGER
the area goes from this character on.
to: EV_FOLDING_AREA -> INTEGER
the area goes until this character.
folded: EV_FOLDING_AREA -> BOOLEAN
is it folded or not?
fold: EV_FOLDING_AREA -> EV_FOLDING_AREA
fold the area.
unfold: EV_FOLDING_AREA -> EV_FOLDING_AREA
unfold the area.
content: EV_FOLDING_AREA x EV_FOLDING_WIDGET -> STRING
the content of the area.

the structure would be controlled by the controller which knows of the AST.

as always, this is only a proposal.

Bru 13:03, 9 May 2006 (CEST)

How does Eiffel implement text as a sequence of characters? line by line? That will greatly influence our implementation of the folding widget I guess. A "folding area" will then contain the lines themselves and the start and end coordinates of the area, so that when the displayer draws the editor area it gets those coordinates from the folding controller and doesn't display those lines but puts a symbol there instead. Just thinking out loud here...

ADT

moved from front-page
Sanakan 02:40, 18 June 2006 (CEST)

NOTE: to be revised!

Types

FOLDING_WIDGET, TEXT_BLOCK, INTEGER, BOOLEAN,

Features

new -> FOLDING_WIDGET
definearea: FOLDING_WIDGET X HIGHLIGHTED_TEXT_BLOCK -> FOLDING_WIDGET
from: FOLDING_WIDGET -> INTEGER
to: FOLDING_WIDGET -> INTEGER
folded: FOLDING_WIDGET -> BOOLEAN
fold: FOLDING_WIDGET -> FOLDING_WIDGET
unfold: FOLDING_WIDGET -> FOLDING_WIDGET
content: FOLDING_WIDGET -> BLOCK
numberoflines: FOLDING_WIDGET -> INTEGER

Prerequisites

none

Axioms

for all w,v :: FOLDING_WIDGET, tb :: TEXT_BLOCK

from(definearea(w,tb)) = firstline(tb) to(definearea(w,tb) = lastline(tb) content(new) = NULL content(definearea(w,tb)) = tb numberoflines(new) = 0 numberoflines(definearea(w,tb)) = to(definearea(w,tb)) - from(definearea(w,tb)) folded(new) = false folded(fold(w)) = true