Zero3K
/
presto
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
Opera 12.15 Source Code
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22 Commits
1 Branch
Tree: e1d750352d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e1d750352d'
${ noResults }
presto/modules/documentedit/documentedit.ot

documentedit.ot 66KB
Raw Blame History

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174 
  1. /* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */

  2. group "DocumentEdit";

  3. require init;

  4. require DOCUMENT_EDIT_SUPPORT;

  5. 

  6. include "modules/documentedit/OpDocumentEdit.h";

  7. include "modules/documentedit/OpDocumentEditUtils.h";

  8. include "modules/dochand/fdelm.h";

  9. include "modules/doc/frm_doc.h";

  10. include "modules/doc/html_doc.h";

  11. include "modules/logdoc/selection.h";

  12. include "modules/logdoc/selectionpoint.h";

  13. include "modules/doc/caret_painter.h";

  14. 

  15. global

  16. {

  17. 	OpDocumentEdit* GetDocumentEdit()

  18. 	{

  19. 		if (FramesDocElm* ifrmroot = state.doc->GetIFrmRoot())

  20. 			if (ifrmroot->FirstChild())

  21. 				return ifrmroot->FirstChild()->GetCurrentDoc()->GetDocumentEdit();

  22. 

  23. 		return NULL;

  24. 	}

  25. 

  26. 	HTML_Element* GetSelectToCaretElement(OpDocumentEdit* edit)

  27. 	{

  28. 		HTML_Element* li_element = edit->FindElementAfterOfType(edit->GetBody(), HE_LI, FALSE);

  29. 		if (!li_element)

  30. 			return NULL;

  31. 

  32. 		HTML_Element* candidate = li_element->FirstChild();

  33. 		if (candidate && candidate->GetIsListMarkerPseudoElement())

  34. 			candidate = candidate->Suc();

  35. 

  36. 		return candidate;

  37. 	}

  38. }

  39. 

  40. html

  41. {

  42. 	//! <script>

  43. 	//! function do_onload()

  44. 	//! {

  45. 	//!   document.getElementById('edit').contentDocument.designMode = 'on';

  46. 	//! }

  47. 	//! </script>

  48. 	//! <body onload="do_onload()">

  49. 	//! <iframe id="edit" width="40" height="40"></iframe>

  50. 	//! </body>

  51. }

  52. 

  53. test("ExecuteCommand_EmptyDoc") language ecmascript;

  54. {

  55. 	verify(document.getElementById('edit').contentDocument.designMode == 'on');

  56. 	verify(document.getElementById('edit').contentDocument.queryCommandEnabled('backcolor'));

  57. 	document.getElementById('edit').contentDocument.execCommand('backcolor', false, '#AA8855');

  58. }

  59. 

  60. html

  61. {

  62. 	//! <script>

  63. 	//! function do_onload()

  64. 	//! {

  65. 	//!   var doc = document.getElementById('edit').contentDocument;

  66. 	//!   doc.open();

  67. 	//!   doc.write("<HTML><BODY>Some <EM>italic</EM> and <B>bold</B> text!</BODY></HTML>");

  68. 	//!   doc.close();

  69. 	//!   doc = document.getElementById('edit').contentDocument;

  70. 	//!   doc.designMode = 'on';

  71. 	//! }

  72. 	//! </script>

  73. 	//! <body onload="do_onload()">

  74. 	//! <iframe id="edit" width="40" height="40"></iframe>

  75. 	//! </body>

  76. }

  77. 

  78. test("WriteTemplateDocument") language ecmascript;

  79. {

  80. 	var doc = document.getElementById('edit').contentDocument;

  81. 	verify(doc.designMode == 'on');

  82. 	verify(doc.body.innerHTML == "Some <em>italic</em> and <b>bold</b> text!");

  83. }

  84. 

  85. test("EmptyDocument") language ecmascript;

  86. {

  87. 	var doc = document.getElementById('edit').contentDocument;

  88. 	doc.body.innerHTML = "";

  89. 	doc.execCommand('bold', false, null);

  90. 	verify(doc.body);

  91. }

  92. 

  93. test("EditDocument1") language C++;

  94. {

  95. 	OpDocumentEdit* edit = GetDocumentEdit();

  96. 	verify(edit);

  97. 	edit->InsertText(UNI_L("test"), 4);

  98. }

  99. 

  100. test("EditDocument2") language ecmascript;

  101. {

  102. 	var doc = document.getElementById('edit').contentDocument;

  103. 	verify(doc.body.innerHTML == "<strong>test</strong>");

  104. }

  105. 

  106. subtest VerifyHtml(OpDocumentEdit* edit, const uni_char* text)

  107. {

  108. 	OpString tmp;

  109. 	edit->GetTextHTML(tmp);

  110. 

  111. 	// Turn unicode nonbreaking space into &nbsp; since we can't (and don't want to) write teststrings with unicode character.

  112. 	while (1)

  113. 	{

  114. 		int pos = tmp.FindI(UNI_L("\xA0"));

  115. 		if (pos == KNotFound)

  116. 			break;

  117. 		tmp.Delete(pos, 1);

  118. 		tmp.Insert(pos, UNI_L("&nbsp;"));

  119. 	}

  120. 

  121. 	if (tmp.CompareI(text))

  122. 	{

  123. 		output("Value: \"%s\" Expected value: \"%s\"\n", ST_down(tmp.CStr() ? tmp.CStr() : UNI_L("")), ST_down(text ? text : UNI_L("")));

  124. 	}

  125. 

  126. 	verify(tmp.CompareI(text) == 0);

  127. }

  128. 

  129. test("StyleStartEnd") language C++;

  130. {

  131. 	OpDocumentEdit* edit = GetDocumentEdit();

  132. 	verify(edit);

  133. 

  134. 	edit->Clear();

  135. 

  136. 	edit->InsertText(UNI_L("x"), 1);

  137. 	verify(VerifyHtml(edit, UNI_L("x")));

  138. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  139. 	edit->InsertText(UNI_L("x"), 1);

  140. 	verify(VerifyHtml(edit, UNI_L("x<STRONG>x</STRONG>")));

  141. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  142. 	verify(VerifyHtml(edit, UNI_L("x<STRONG>x</STRONG>")));

  143. 	edit->InsertText(UNI_L("x"), 1);

  144. 

  145. 	verify(VerifyHtml(edit, UNI_L("x<STRONG>x</STRONG>x")));

  146. 

  147. 	edit->Clear();

  148. 

  149. 	edit->InsertText(UNI_L("x"), 1);

  150. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  151. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  152. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  153. 	edit->InsertText(UNI_L("x"), 1);

  154. 	verify(VerifyHtml(edit, UNI_L("x<EM>x</EM>")));

  155. 

  156. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  157. 	edit->InsertText(UNI_L("x"), 1);

  158. 	verify(VerifyHtml(edit, UNI_L("x<EM>x<STRONG>x</STRONG></EM>")));

  159. 

  160. /*	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  161. 	edit->InsertText(UNI_L("x"), 1);

  162. 	verify(VerifyHtml(edit, UNI_L("x<EM>x<STRONG>x</STRONG>x</EM>")));

  163. 

  164. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  165. 	edit->InsertText(UNI_L("x"), 1);

  166. 	verify(VerifyHtml(edit, UNI_L("x<EM>x<STRONG>x</STRONG>x</EM>x")));*/

  167. }

  168. 

  169. test("StyleAndWhitespace") language C++;

  170. {

  171. 	OpDocumentEdit* edit = GetDocumentEdit();

  172. 	verify(edit);

  173. 

  174. 	edit->SetTextHTML(UNI_L("<STRONG>one two three</STRONG>"));

  175. 

  176. 	// Select "two"

  177. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  178. 	verify(elm);

  179. 	edit->m_caret.Place(elm, 4);

  180. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 7);

  181. 

  182. 	// Remove bold from selection

  183. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  184. 	verify(VerifyHtml(edit, UNI_L("<STRONG>one </STRONG>two<STRONG> three</STRONG>")));

  185. 

  186. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  187. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_REMOVEFORMAT);

  188. 	verify(VerifyHtml(edit, UNI_L("one two three")));

  189. 

  190. 	// Select "two"

  191. 	elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  192. 	verify(elm);

  193. 	edit->m_caret.Place(elm, 4, FALSE, FALSE);

  194. 	OpInputAction action(OpInputAction::ACTION_RANGE_NEXT_CHARACTER);

  195. 	edit->EditAction(&action);

  196. 	edit->EditAction(&action);

  197. 	edit->EditAction(&action);

  198. 

  199. 	// Set bold and italic, and remove italic.

  200. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  201. 	verify(VerifyHtml(edit, UNI_L("one <STRONG>two</STRONG> three")));

  202. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  203. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  204. 	verify(VerifyHtml(edit, UNI_L("one <STRONG>two</STRONG> three")));

  205. }

  206. 

  207. test("WhiteSpaceNBSP1") language C++;

  208. {

  209. 	OpDocumentEdit* edit = GetDocumentEdit();

  210. 	verify(edit);

  211. 

  212. 	OpInputAction backspace(OpInputAction::ACTION_BACKSPACE);

  213. 

  214. 	edit->SetTextHTML(UNI_L(""));

  215. 		// Adding space/text

  216. 		edit->InsertText(UNI_L(" "), 1);

  217. 		verify(VerifyHtml(edit, UNI_L("&nbsp;")));

  218. 		edit->InsertText(UNI_L("A"), 1);

  219. 		verify(VerifyHtml(edit, UNI_L("&nbsp;A")));

  220. 		edit->InsertText(UNI_L(" "), 1);

  221. 		verify(VerifyHtml(edit, UNI_L("&nbsp;A&nbsp;")));

  222. 		edit->InsertText(UNI_L("B"), 1);

  223. 		verify(VerifyHtml(edit, UNI_L("&nbsp;A B")));

  224. 		// Removing text

  225. 		edit->OnInputAction(&backspace);

  226. 		verify(VerifyHtml(edit, UNI_L("&nbsp;A&nbsp;")));

  227. }

  228. 

  229. test("WhiteSpaceNBSP2") language C++;

  230. {

  231. 	OpDocumentEdit* edit = GetDocumentEdit();

  232. 	verify(edit);

  233. 

  234. 	edit->SetTextHTML(UNI_L(""));

  235. 		// Adding lots of space

  236. 		edit->InsertText(UNI_L(" "), 1);

  237. 		edit->InsertText(UNI_L(" "), 1);

  238. 		verify(VerifyHtml(edit, UNI_L("&nbsp;&nbsp;")));

  239. 		edit->InsertText(UNI_L(" "), 1);

  240. 		verify(VerifyHtml(edit, UNI_L("&nbsp; &nbsp;")));

  241. }

  242. 

  243. test("WhiteSpaceNBSP3") language C++;

  244. {

  245. 	OpDocumentEdit* edit = GetDocumentEdit();

  246. 	verify(edit);

  247. 

  248. 	OpInputAction backspace(OpInputAction::ACTION_BACKSPACE);

  249. 

  250. 	edit->SetTextHTML(UNI_L("AB"));

  251. 	edit->m_caret.Move(FALSE, FALSE);

  252. 		// Adding lots of space

  253. 		edit->InsertText(UNI_L(" "), 1);

  254. 		verify(VerifyHtml(edit, UNI_L("A B")));

  255. 		edit->InsertText(UNI_L(" "), 1);

  256. 		verify(VerifyHtml(edit, UNI_L("A &nbsp;B")));

  257. 		edit->InsertText(UNI_L(" "), 1);

  258. 		verify(VerifyHtml(edit, UNI_L("A &nbsp; B")));

  259. 		// Removing space

  260. 		edit->OnInputAction(&backspace);

  261. 		verify(VerifyHtml(edit, UNI_L("A &nbsp;B")));

  262. 		edit->OnInputAction(&backspace);

  263. 		verify(VerifyHtml(edit, UNI_L("A B")));

  264. }

  265. 

  266. test("WhiteSpaceNBSP4") language C++;

  267. {

  268. 	OpDocumentEdit* edit = GetDocumentEdit();

  269. 	verify(edit);

  270. 

  271. 	edit->SetTextHTML(UNI_L("<DIV>A</DIV>after"));

  272. 		HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  273. 		verify(elm);

  274. 		edit->m_caret.Place(elm, 1);

  275. 		edit->InsertText(UNI_L(" "), 1);

  276. 		verify(VerifyHtml(edit, UNI_L("<DIV>A&nbsp;</DIV>after")));

  277. 

  278. 	edit->SetTextHTML(UNI_L("<SPAN>A</SPAN>after"));

  279. 		elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  280. 		verify(elm);

  281. 		edit->m_caret.Place(elm, 1);

  282. 		edit->InsertText(UNI_L(" "), 1);

  283. 		verify(VerifyHtml(edit, UNI_L("<SPAN>A </SPAN>after")));

  284. }

  285. 

  286. test("WhiteSpaceNBSP5") language C++;

  287. {

  288. 	OpDocumentEdit* edit = GetDocumentEdit();

  289. 	verify(edit);

  290. 

  291. 	OpInputAction backspace(OpInputAction::ACTION_BACKSPACE);

  292. 

  293. 	edit->SetTextHTML(UNI_L("<PRE>A</PRE>"));

  294. 		edit->InsertText(UNI_L(" "), 1);

  295. 		verify(VerifyHtml(edit, UNI_L("<PRE>A </PRE>")));

  296. 		edit->InsertText(UNI_L(" "), 1);

  297. 		verify(VerifyHtml(edit, UNI_L("<PRE>A  </PRE>")));

  298. 		edit->OnInputAction(&backspace);

  299. 		verify(VerifyHtml(edit, UNI_L("<PRE>A </PRE>")));

  300. }

  301. 

  302. test("WhiteSpaceNBSP6") language C++;

  303. {

  304. 	OpDocumentEdit* edit = GetDocumentEdit();

  305. 	verify(edit);

  306. 

  307. 	OpInputAction backspace(OpInputAction::ACTION_BACKSPACE);

  308. 

  309. 	edit->SetTextHTML(UNI_L("<BR>bb<BR>"));

  310. 	edit->m_caret.PlaceFirst();

  311. 	edit->InsertText(UNI_L(" "), 1);

  312. 	edit->InsertText(UNI_L(" "), 1);

  313. 	edit->InsertText(UNI_L(" "), 1);

  314. 	verify(VerifyHtml(edit, UNI_L("&nbsp; &nbsp;<BR>bb<BR>")));

  315. 	edit->OnInputAction(&backspace);

  316. 	verify(VerifyHtml(edit, UNI_L("&nbsp;&nbsp;<BR>bb<BR>")));

  317. 	edit->OnInputAction(&backspace);

  318. 	verify(VerifyHtml(edit, UNI_L("&nbsp;<BR>bb<BR>")));

  319. 	edit->OnInputAction(&backspace);

  320. 	verify(VerifyHtml(edit, UNI_L("<BR>bb<BR>")));

  321. }

  322. 

  323. test("StyleWithDummy") language C++;

  324. {

  325. 	OpDocumentEdit* edit = GetDocumentEdit();

  326. 	verify(edit);

  327. 

  328. 	edit->Clear();

  329. 

  330. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  331. 	edit->InsertText(UNI_L("a"), 1);

  332. 	verify(VerifyHtml(edit, UNI_L("<EM>a</EM>")));

  333. 

  334. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  335. 	edit->InsertText(UNI_L("b"), 1);

  336. 	verify(VerifyHtml(edit, UNI_L("<EM>a<STRONG>b</STRONG></EM>")));

  337. }

  338. 

  339. test("InsertFontFaceInFont") language C++;

  340. {

  341. 	OpDocumentEdit* edit = GetDocumentEdit();

  342. 	verify(edit);

  343. 

  344. 	edit->Clear();

  345. 

  346. 	edit->SetTextHTML(UNI_L("<P><FONT FACE=\"serif\">ABC</FONT></P>"));

  347. 

  348. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  349. 	verify(elm);

  350. 	edit->m_caret.Place(elm, 1);

  351. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 2);

  352. 

  353. 	uni_char font_name[11]; /* ARRAY OK 2011-06-23 stighal */

  354. 	uni_strcpy(font_name, UNI_L("sans-serif"));

  355. 	// This will eventually call GetFirstFontNumber, which requires a non-const string as it changes it temporarily

  356. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FONTNAME, FALSE, font_name);

  357. 	verify(VerifyHtml(edit, UNI_L("<P><FONT FACE=\"serif\">A</FONT><FONT FACE=\"sans-serif\">B</FONT><FONT FACE=\"serif\">C</FONT></P>")));

  358. 

  359. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  360. 

  361. 	elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  362. 	verify(elm);

  363. 	edit->m_caret.Place(elm, 1);

  364. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 2);

  365. 

  366. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FONTSIZE, FALSE, UNI_L("5"));

  367. 	verify(VerifyHtml(edit, UNI_L("<P><FONT FACE=\"serif\">A<FONT SIZE=\"5\">B</FONT>C</FONT></P>")));

  368. }

  369. 

  370. test("ForegroundColor") language C++;

  371. {

  372. 	OpDocumentEdit* edit = GetDocumentEdit();

  373. 	verify(edit);

  374. 

  375. 	edit->Clear();

  376. 

  377. 	edit->SetTextHTML(UNI_L("12"));

  378. 

  379. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORECOLOR, FALSE, UNI_L("#FF0000"));

  380. 	edit->InsertText(UNI_L("34"), 2);

  381. 	verify(VerifyHtml(edit, UNI_L("12<FONT color=\"#ff0000\">34</FONT>")));

  382. 

  383. 	edit->InsertText(UNI_L("56"), 2);

  384. 	verify(VerifyHtml(edit, UNI_L("12<FONT color=\"#ff0000\">3456</FONT>")));

  385. 

  386. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORECOLOR, FALSE, UNI_L("#000000"));

  387. 	edit->InsertText(UNI_L("78"), 2);

  388. 	verify(VerifyHtml(edit, UNI_L("12<FONT color=\"#ff0000\">3456</FONT>78")));

  389. 

  390. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORECOLOR, FALSE, UNI_L("#FF0000"));

  391. 	edit->InsertText(UNI_L("90"), 2);

  392. 	verify(VerifyHtml(edit, UNI_L("12<FONT color=\"#ff0000\">3456</FONT>78<FONT color=\"#ff0000\">90</FONT>")));

  393. }

  394. 

  395. test("ForegroundColorSelection") language C++;

  396. {

  397. 	OpDocumentEdit* edit = GetDocumentEdit();

  398. 	verify(edit);

  399. 

  400. 	edit->Clear();

  401. 

  402. 	edit->SetTextHTML(UNI_L("0123"));

  403. 

  404. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  405. 	verify(elm);

  406. 	edit->m_caret.Place(elm, 0);

  407. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 2);

  408. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORECOLOR, FALSE, UNI_L("#FF0000"));

  409. 	verify(VerifyHtml(edit, UNI_L("<FONT color=\"#ff0000\">01</FONT>23")));

  410. 

  411. 	elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  412. 	verify(elm);

  413. 	edit->m_caret.Place(elm, 0);

  414. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 2);

  415. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORECOLOR, FALSE, UNI_L("#000000"));

  416. 	verify(VerifyHtml(edit, UNI_L("0123")));

  417. }

  418. 

  419. test("ReplaceInDivAndUndo") language C++;

  420. {

  421. 	OpDocumentEdit* edit = GetDocumentEdit();

  422. 	verify(edit);

  423. 

  424. 	edit->SetTextHTML(UNI_L("<DIV>inside</DIV>after"));

  425. 

  426. 	// Select "inside"

  427. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  428. 	verify(elm);

  429. 	edit->m_caret.Place(elm, 0);

  430. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 6);

  431. 

  432. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  433. 	verify(VerifyHtml(edit, UNI_L("<DIV><BR></DIV>after")));

  434. 

  435. 	edit->InsertText(UNI_L("newtextinside"), 13);

  436. 	verify(VerifyHtml(edit, UNI_L("<DIV>newtextinside</DIV>after")));

  437. 

  438. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  439. 	verify(VerifyHtml(edit, UNI_L("<DIV><BR></DIV>after")));

  440. 

  441. 	edit->InsertTextHTML(UNI_L("<P>newpinside</P>"), 17);

  442. 	verify(VerifyHtml(edit, UNI_L("<DIV><P>newpinside</P></DIV>after")));

  443. }

  444. 

  445. test("ReplaceBeforeDivAndUndo") language C++;

  446. {

  447. 	OpDocumentEdit* edit = GetDocumentEdit();

  448. 	verify(edit);

  449. 

  450. 	edit->SetTextHTML(UNI_L("before<DIV>inside</DIV>"));

  451. 

  452. 	// Select "before"

  453. 	edit->m_caret.PlaceFirst();

  454. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 6);

  455. 

  456. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  457. 

  458. 	// Delete empty text at caret - and expect caret to jump inside the content of the now removed DIV

  459. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  460. 

  461. 	edit->InsertText(UNI_L("newtext"), 7);

  462. 	verify(VerifyHtml(edit, UNI_L("newtextinside")));

  463. 

  464. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  465. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  466. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  467. 	verify(VerifyHtml(edit, UNI_L("before<DIV>inside</DIV>")));

  468. 

  469. 	// Let's try to redo...

  470. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_REDO);

  471. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_REDO);

  472. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_REDO);

  473. 	verify(VerifyHtml(edit, UNI_L("newtextinside")));

  474. 

  475. 	// ...and undo again

  476. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  477. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  478. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  479. 	verify(VerifyHtml(edit, UNI_L("before<DIV>inside</DIV>")));

  480. 

  481. 	edit->m_caret.PlaceFirst();

  482. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 6);

  483. 

  484. 	edit->InsertText(UNI_L("newtextbefore"), 13);

  485. 	verify(VerifyHtml(edit, UNI_L("newtextbefore<DIV>inside</DIV>")));

  486. }

  487. 

  488. test("DeleteIntoContainer") language C++;

  489. {

  490. 	OpDocumentEdit* edit = GetDocumentEdit();

  491. 	verify(edit);

  492. 

  493. 	edit->SetTextHTML(UNI_L("<DIV>insideX</DIV>Xafter"));

  494. 

  495. 	HTML_Element *helm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  496. 	edit->m_caret.Place(helm, 6);

  497. 	helm = edit->FindEditableElement(helm, TRUE, FALSE, FALSE);

  498. 	verify(helm);

  499. 	edit->m_selection.SelectToCaret(helm, 1);

  500. 

  501. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  502. 

  503. 	verify(VerifyHtml(edit, UNI_L("<DIV>insideafter</DIV>")));

  504. }

  505. 

  506. test("GetTextHTMLFromNamedElement") language C++;

  507. {

  508. 	OpDocumentEdit* edit = GetDocumentEdit();

  509. 	verify(edit);

  510. 

  511. 	edit->SetTextHTML(UNI_L("<DIV id=a>A</DIV><DIV id=b>B</DIV>after"));

  512. 

  513. 	OpString text;

  514. 

  515. 	edit->GetTextHTMLFromNamedElement(text, UNI_L("a"), FALSE);

  516. 	verify(text.Compare(UNI_L("A")) == 0);

  517. 

  518. 	edit->GetTextHTMLFromNamedElement(text, UNI_L("a"), TRUE);

  519. 	verify(text.Compare(UNI_L("<div id=\"a\">A</div>")) == 0);

  520. }

  521. 

  522. test("DeleteNamedElement") language C++;

  523. {

  524. 	OpDocumentEdit* edit = GetDocumentEdit();

  525. 	verify(edit);

  526. 

  527. 	edit->SetTextHTML(UNI_L("<DIV id=a>A</DIV><DIV id=b>B</DIV>after"));

  528. 

  529. 	edit->DeleteNamedElement(UNI_L("b"));

  530. 	verify(VerifyHtml(edit, UNI_L("<DIV id=\"a\">A</DIV>after")));

  531. }

  532. 

  533. test("UndoGrouping") language C++;

  534. {

  535. 	OpDocumentEdit* edit = GetDocumentEdit();

  536. 	verify(edit);

  537. 

  538. 	edit->Clear();

  539. 	edit->InsertText(UNI_L("a"), 1, TRUE);

  540. 	edit->InsertText(UNI_L("a"), 1, TRUE);

  541. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  542. 	edit->InsertText(UNI_L("b"), 1, TRUE);

  543. 	verify(VerifyHtml(edit, UNI_L("b")));

  544. 

  545. 	edit->Clear();

  546. 	edit->InsertText(UNI_L("a"), 1, TRUE);

  547. 	edit->InsertText(UNI_L("a"), 1, TRUE);

  548. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  549. 	edit->InsertText(UNI_L("b"), 1, TRUE);

  550. 	verify(VerifyHtml(edit, UNI_L("b")));

  551. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  552. 	verify(VerifyHtml(edit, UNI_L("aa")));

  553. }

  554. 

  555. test("DeleteDiv") language C++;

  556. {

  557. 	OpDocumentEdit* edit = GetDocumentEdit();

  558. 	verify(edit);

  559. 

  560. 	edit->SetTextHTML(UNI_L("before<DIV>inside</DIV>"));

  561. 

  562. 	// Select "before"

  563. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  564. 	verify(elm);

  565. 	edit->m_caret.Place(elm, 6);

  566. 

  567. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  568. 

  569. 	verify(VerifyHtml(edit, UNI_L("beforeinside")));

  570. }

  571. 

  572. test("SplitLineCaretPosition") language C++;

  573. {

  574. 	OpDocumentEdit* edit = GetDocumentEdit();

  575. 	verify(edit);

  576. 

  577. 	edit->SetTextHTML(UNI_L("<P>first</P><P>second</P><P><BR></P>"));

  578. 

  579. 	// Set caret after "fi"

  580. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  581. 	verify(elm);

  582. 	edit->m_caret.Place(elm, 2);

  583. 

  584. 	edit->InsertBreak(TRUE, TRUE);

  585. 

  586. 	verify(VerifyHtml(edit, UNI_L("<P>fi</P><P>rst</P><P>second</P><P><BR></P>")));

  587. 

  588. 	edit->InsertText(UNI_L("thi"), 3, TRUE);

  589. 

  590. 	verify(VerifyHtml(edit, UNI_L("<P>fi</P><P>thirst</P><P>second</P><P><BR></P>")));

  591. }

  592. 

  593. test("KeepWhenTidy") language C++;

  594. {

  595. 	OpDocumentEdit* edit = GetDocumentEdit();

  596. 	verify(edit);

  597. 

  598. 	edit->SetTextHTML(UNI_L("before<TABLE><TR><TD>content</TD></TR></TABLE>after"));

  599. 

  600. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  601. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  602. 	verify(VerifyHtml(edit, UNI_L("<BR>")));

  603. 

  604. 	edit->SetTextHTML(UNI_L("before<TABLE><TR><TD>content</TD></TR></TABLE>after"));

  605. 	edit->m_caret.PlaceFirst();

  606. 	OpInputAction action(OpInputAction::ACTION_RANGE_NEXT_CHARACTER);

  607. 	for(int i = 0; i < 8; i++)

  608. 		edit->OnInputAction(&action);

  609. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  610. 	verify(VerifyHtml(edit, UNI_L("<TABLE><TBODY><TR><TD>ontent</TD></TR></TBODY></TABLE>after")));

  611. }

  612. 

  613. test("KeepWhenTidyIfEmpty") language C++;

  614. {

  615. 	OpDocumentEdit* edit = GetDocumentEdit();

  616. 	verify(edit);

  617. 

  618. 	edit->SetTextHTML(UNI_L("before<TEXTAREA>content</TEXTAREA>after"));

  619. 	verify(VerifyHtml(edit, UNI_L("before<TEXTAREA>content</TEXTAREA>after")));

  620. 

  621. 	edit->SetTextHTML(UNI_L("before<TEXTAREA></TEXTAREA>after"));

  622. 	edit->m_caret.PlaceFirst();

  623. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  624. 	verify(VerifyHtml(edit, UNI_L("efore<TEXTAREA></TEXTAREA>after")));

  625. 

  626. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  627. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  628. 	verify(VerifyHtml(edit, UNI_L("<BR>")));

  629. }

  630. 

  631. test("InsertListItems") language C++;

  632. {

  633. 	OpDocumentEdit* edit = GetDocumentEdit();

  634. 	verify(edit);

  635. 

  636. 	// New list

  637. 	edit->SetTextHTML(UNI_L("item1"));

  638. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  639. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI></OL>")));

  640. 

  641. 	// New listitem

  642. 	edit->InsertBreak();

  643. 	edit->InsertText(UNI_L("item2"), 5, TRUE);

  644. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI><LI>item2</LI></OL>")));

  645. 

  646. 	// New listitem that splits current

  647. 	edit->InsertText(UNI_L("item3"), 5, TRUE);

  648. 	for(int i = 0; i < 5; i++)

  649. 		edit->m_caret.Move(FALSE, FALSE);

  650. 	edit->InsertBreak();

  651. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI><LI>item2</LI><LI>item3</LI></OL>")));

  652. 

  653. 	// Break 2 times to split the list

  654. 	edit->InsertBreak();

  655. 	edit->InsertBreak();

  656. 	edit->InsertText(UNI_L("noitem"), 6, TRUE);

  657. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI><LI>item2</LI></OL><P>noitem</P><OL><LI>item3</LI></OL>")));

  658. }

  659. 

  660. test("InsertListMultipleItems") language C++;

  661. {

  662. 	OpDocumentEdit* edit = GetDocumentEdit();

  663. 	verify(edit);

  664. 

  665. 	edit->SetTextHTML(UNI_L("<P>item1<br></P><P>item2<br></P><P>item3<br></P>"));

  666. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  667. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  668. 

  669. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1<BR></LI><LI>item2<BR></LI><LI>item3<BR></LI></OL>")));

  670. }

  671. 

  672. test("RemoveList") language C++;

  673. {

  674. 	OpDocumentEdit* edit = GetDocumentEdit();

  675. 	verify(edit);

  676. 

  677. 	edit->SetTextHTML(UNI_L("<OL><LI>item1</LI><LI>item2</LI><LI>item3</LI></OL>"));

  678. 

  679. 	// Remove item 1

  680. 	edit->m_caret.PlaceFirst();

  681. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  682. 	verify(VerifyHtml(edit, UNI_L("<P>item1</P><OL><LI>item2</LI><LI>item3</LI></OL>")));

  683. 

  684. 	// Reverse and jump to item 2

  685. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  686. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI><LI>item2</LI><LI>item3</LI></OL>")));

  687. 	edit->m_caret.Place(OpWindowCommander::CARET_DOWN);

  688. 

  689. 	// Remove item 2

  690. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  691. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI></OL><P>item2</P><OL><LI>item3</LI></OL>")));

  692. 

  693. 	// Reverse and select all

  694. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  695. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  696. 

  697. 	// Remove entire list

  698. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  699. 	verify(VerifyHtml(edit, UNI_L("<P>item1</P><P>item2</P><P>item3</P>")));

  700. }

  701. 

  702. test("ToggleListOrderingInNestledList") language C++;

  703. {

  704. 	OpDocumentEdit* edit = GetDocumentEdit();

  705. 	verify(edit);

  706. 

  707. 	edit->SetTextHTML(UNI_L("<OL><LI><OL><LI>item1</LI></OL></LI><LI><OL><LI>item2</LI></OL></LI></OL>"));

  708. 

  709. 	// After this should one ordered list contain one un-ordered list with item1 and item2

  710. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  711. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTUNORDEREDLIST);

  712. 	verify(VerifyHtml(edit, UNI_L("<OL><LI><UL><LI>item1</LI><LI>item2</LI></UL></LI></OL>")));

  713. 

  714. 	// After this should one ordered list contain one ordered list with item1 and item2

  715. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  716. 	verify(VerifyHtml(edit, UNI_L("<OL><LI><OL><LI>item1</LI><LI>item2</LI></OL></LI></OL>")));

  717. 

  718. 	// After this should one ordered list contain item1 and item2

  719. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTORDEREDLIST);

  720. 	verify(VerifyHtml(edit, UNI_L("<OL><LI>item1</LI><LI>item2</LI></OL>")));

  721. }

  722. 

  723. test("IndentAndOutdent") language C++;

  724. {

  725. 	OpDocumentEdit* edit = GetDocumentEdit();

  726. 	verify(edit);

  727. 

  728. 	edit->SetTextHTML(UNI_L("item1<OL><LI>item2</LI><LI>item3</LI></OL>"));

  729. 

  730. 	edit->m_caret.PlaceFirst();

  731. 	HTML_Element *item2 = GetSelectToCaretElement(edit);

  732. 	verify(item2);

  733. 	edit->m_selection.SelectToCaret(item2, 1);

  734. 

  735. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INDENT);

  736. 	verify(VerifyHtml(edit, UNI_L("<BLOCKQUOTE>item1</BLOCKQUOTE><OL><OL><LI>item2</LI></OL><LI>item3</LI></OL>")));

  737. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_OUTDENT);

  738. 	verify(VerifyHtml(edit, UNI_L("item1<OL><LI>item2</LI><LI>item3</LI></OL>")));

  739. }

  740. 

  741. test("IndentAndOutdentCSS") language C++;

  742. {

  743. 	OpDocumentEdit* edit = GetDocumentEdit();

  744. 	verify(edit);

  745. 

  746. 	edit->SetTextHTML(UNI_L("item1<OL><LI>item2</LI><LI>item3</LI></OL>"));

  747. 

  748. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_STYLEWITHCSS, FALSE, UNI_L("true"));

  749. 	edit->m_caret.PlaceFirst();

  750. 	HTML_Element *item2 = GetSelectToCaretElement(edit);

  751. 	verify(item2);

  752. 	edit->m_selection.SelectToCaret(item2, 1);

  753. 

  754. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INDENT);

  755. 	verify(VerifyHtml(edit, UNI_L("<DIV style=\"margin-left: 40px !important;\">item1</DIV><OL><OL><LI>item2</LI></OL><LI>item3</LI></OL>")));

  756. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_OUTDENT);

  757. 	verify(VerifyHtml(edit, UNI_L("<DIV style=\"margin-left: 0px !important;\">item1</DIV><OL><LI>item2</LI><LI>item3</LI></OL>")));

  758. }

  759. 

  760. test("RemoveLeadingWhitespace") language C++;

  761. {

  762. 	OpDocumentEdit* edit = GetDocumentEdit();

  763. 	verify(edit);

  764. 

  765. 	edit->SetTextHTML(UNI_L("<STRONG>A</STRONG> BCD"));

  766. 	edit->m_caret.PlaceFirst();

  767. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  768. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  769. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  770. 	verify(VerifyHtml(edit, UNI_L("CD")));

  771. }

  772. 

  773. test("FormatBlock") language C++;

  774. {

  775. 	OpDocumentEdit* edit = GetDocumentEdit();

  776. 	verify(edit);

  777. 

  778. 	edit->SetTextHTML(UNI_L("Row1 with <B>some</B> <IMG SRC=\"blah\"> inlines.<BR>Row2"));

  779. 	edit->m_caret.PlaceFirst();

  780. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORMATBLOCK, FALSE, UNI_L("H1"));

  781. 

  782. 	verify(VerifyHtml(edit, UNI_L("<H1>Row1 with <B>some</B> <IMG SRC=\"blah\"> inlines.<BR></H1>Row2")));

  783. 

  784. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  785. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORMATBLOCK, FALSE, UNI_L("H2"));

  786. 

  787. 	verify(VerifyHtml(edit, UNI_L("<H2>Row1 with <B>some</B> <IMG SRC=\"blah\"> inlines.<BR></H2><H2>Row2</H2>")));

  788. }

  789. 

  790. test("CreateLink") language C++;

  791. {

  792. 	OpDocumentEdit* edit = GetDocumentEdit();

  793. 	verify(edit);

  794. 

  795. 	edit->SetTextHTML(UNI_L("link text"));

  796. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  797. 

  798. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_CREATELINK, FALSE, UNI_L("HTTP://aaaa"));

  799. 	verify(VerifyHtml(edit, UNI_L("<A HREF=\"HTTP://aaaa\">link text</A>")));

  800. 

  801. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_CREATELINK, FALSE, UNI_L("HTTP://bbbb"));

  802. 	verify(VerifyHtml(edit, UNI_L("<A HREF=\"HTTP://bbbb\">link text</A>")));

  803. }

  804. 

  805. test("MoveCaretOverWhitespace") language C++;

  806. {

  807. 	OpDocumentEdit* edit = GetDocumentEdit();

  808. 	verify(edit);

  809. 

  810. 	edit->SetTextHTML(UNI_L("Two       words"));

  811. 	HTML_Element* elm = edit->FindEditableElement(edit->GetBody(), TRUE, FALSE, FALSE);

  812. 	verify(elm);

  813. 	edit->m_caret.Place(elm, 0);

  814. 

  815. 	// Forward

  816. 	edit->m_caret.Move(TRUE, FALSE);

  817. 	edit->m_caret.Move(TRUE, FALSE);

  818. 	edit->m_caret.Move(TRUE, FALSE);

  819. 	verify(edit->m_caret.GetOffset() == 3);

  820. 

  821. 	edit->m_caret.Move(TRUE, FALSE);

  822. 	verify(edit->m_caret.GetOffset() == 10);

  823. 	edit->m_caret.Move(TRUE, FALSE);

  824. 	verify(edit->m_caret.GetOffset() == 11);

  825. 

  826. 	// Backward

  827. 	edit->m_caret.Move(FALSE, FALSE);

  828. 	verify(edit->m_caret.GetOffset() == 10);

  829. 	edit->m_caret.Move(FALSE, FALSE);

  830. 	verify(edit->m_caret.GetOffset() == 3);

  831. }

  832. 

  833. test("TabInPre") language C++;

  834. {

  835. 	OpDocumentEdit* edit = GetDocumentEdit();

  836. 	verify(edit);

  837. 

  838. 	edit->SetTextHTML(UNI_L(""));

  839. 

  840. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORMATBLOCK, FALSE, UNI_L("PRE"));

  841. 	edit->InsertText(UNI_L("\t"), 1, TRUE);

  842. 	edit->InsertText(UNI_L("\t"), 1, TRUE);

  843. 	verify(VerifyHtml(edit, UNI_L("<pre>\t\t</pre>")));

  844. 

  845. 	edit->m_caret.Move(FALSE, FALSE);

  846. 	edit->InsertText(UNI_L("A"), 1, TRUE);

  847. 	verify(VerifyHtml(edit, UNI_L("<pre>\tA\t</pre>")));

  848. }

  849. 

  850. test("TabInP") language C++;

  851. {

  852. 	OpDocumentEdit* edit = GetDocumentEdit();

  853. 	verify(edit);

  854. 

  855. 	edit->SetTextHTML(UNI_L(""));

  856. 

  857. 	edit->InsertText(UNI_L("\t"), 1, TRUE);

  858. 	verify(VerifyHtml(edit, UNI_L("&nbsp; &nbsp;&nbsp;")));

  859. 

  860. 	edit->InsertText(UNI_L("\t"), 1, TRUE);

  861. 	verify(VerifyHtml(edit, UNI_L("&nbsp; &nbsp; &nbsp; &nbsp;&nbsp;")));

  862. }

  863. 

  864. test("TabAndDeletion") language C++;

  865. {

  866. 	OpDocumentEdit* edit = GetDocumentEdit();

  867. 	verify(edit);

  868. 

  869. 	edit->SetTextHTML(UNI_L(""));

  870. 

  871. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_FORMATBLOCK, FALSE, UNI_L("PRE"));

  872. 	edit->InsertText(UNI_L("\tA\t\t"), 4, TRUE);

  873. 	verify(VerifyHtml(edit, UNI_L("<pre>\tA\t\t</pre>")));

  874. 

  875. 	OpInputAction action(OpInputAction::ACTION_BACKSPACE);

  876. 	edit->OnInputAction(&action);

  877. 	VerifyHtml(edit, UNI_L("<pre>\tA\t</pre>"));

  878. 

  879. 	edit->InsertText(UNI_L("A"), 1, TRUE);

  880. 	verify(VerifyHtml(edit, UNI_L("<pre>\tA\tA</pre>")));

  881. }

  882. 

  883. test("GeneratedContent") language C++;

  884. {

  885. 	OpDocumentEdit* edit = GetDocumentEdit();

  886. 	verify(edit);

  887. 

  888. 	edit->SetTextHTML(UNI_L("<q>Some quoted text</q>"));

  889. 

  890. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  891. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  892. 	verify(VerifyHtml(edit, UNI_L("<q><EM>Some quoted text</EM></q>")));

  893. }

  894. 

  895. test("InsertBreakBR") language C++;

  896. {

  897. 	OpDocumentEdit* edit = GetDocumentEdit();

  898. 	verify(edit);

  899. 

  900. 	edit->SetTextHTML(UNI_L(""));

  901. 	edit->InsertBreak(FALSE, FALSE);

  902. 	verify(VerifyHtml(edit, UNI_L("<br><br>")));

  903. 

  904. 	edit->SetTextHTML(UNI_L("text"));

  905. 	edit->m_caret.PlaceFirst();

  906. 	edit->InsertBreak(FALSE, FALSE);

  907. 	verify(VerifyHtml(edit, UNI_L("<br>text")));

  908. 

  909. 	edit->SetTextHTML(UNI_L(""));

  910. 	edit->InsertText(UNI_L("text"), 6, TRUE);

  911. 	edit->InsertBreak(FALSE, FALSE);

  912. 	verify(VerifyHtml(edit, UNI_L("text<br><br>")));

  913. 

  914. 	edit->InsertBreak(FALSE, FALSE);

  915. 	verify(VerifyHtml(edit, UNI_L("text<br><br><br>")));

  916. 

  917. 	edit->InsertBreak(FALSE, FALSE);

  918. 	verify(VerifyHtml(edit, UNI_L("text<br><br><br><br>")));

  919. }

  920. 

  921. test("RemoveBreakBR") language C++;

  922. {

  923. 	OpDocumentEdit* edit = GetDocumentEdit();

  924. 	verify(edit);

  925. 

  926. 	OpInputAction action(OpInputAction::ACTION_BACKSPACE);

  927. 

  928. 	edit->OnInputAction(&action);

  929. 	verify(VerifyHtml(edit, UNI_L("text<br><br><br>")));

  930. 

  931. 	edit->OnInputAction(&action);

  932. 	verify(VerifyHtml(edit, UNI_L("text<br><br>")));

  933. }

  934. 

  935. test("InsertBreakBR_first_last") language C++;

  936. {

  937. 	OpDocumentEdit* edit = GetDocumentEdit();

  938. 	verify(edit);

  939. 

  940. 	// Insert break at end of H1 should insert *after* the H1

  941. 	edit->SetTextHTML(UNI_L("<h1>header</h1>"));

  942. 	edit->InsertBreak(FALSE, FALSE);

  943. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  944. 	verify(VerifyHtml(edit, UNI_L("<h1>header<br><br></h1>")));

  945. #else

  946. 	verify(VerifyHtml(edit, UNI_L("<h1>header</h1><br>")));

  947. #endif

  948. 

  949. 	// Insert break first in a H1 should insert it *before* the H1

  950. 	edit->m_caret.PlaceFirst();

  951. 	edit->InsertBreak(FALSE, FALSE);

  952. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  953. 	verify(VerifyHtml(edit, UNI_L("<h1><br>header<br><br></h1>")));

  954. #else

  955. 	verify(VerifyHtml(edit, UNI_L("<br><h1>header</h1><br>")));

  956. #endif

  957. 

  958. 	// Same test for links

  959. 

  960. 	edit->SetTextHTML(UNI_L("<a href=\"#\">header</a>"));

  961. 	edit->InsertBreak(FALSE, FALSE);

  962. 	verify(VerifyHtml(edit, UNI_L("<a href=\"#\">header</a><br><br>")));

  963. 

  964. 	edit->m_caret.PlaceFirst();

  965. 	edit->InsertBreak(FALSE, FALSE);

  966. 	verify(VerifyHtml(edit, UNI_L("<br><a href=\"#\">header</a><br><br>")));

  967. 

  968. 	// FIX: Should we split header/links etc if inserting BR-break inside a header?

  969. }

  970. 

  971. test("InsertBreak_first_last_in_block_with_child") language C++;

  972. {

  973. 	OpDocumentEdit* edit = GetDocumentEdit();

  974. 	verify(edit);

  975. 

  976. 	edit->SetTextHTML(UNI_L("<div>first<div>inner</div></div>"));

  977. 	edit->m_caret.PlaceFirst();

  978. 	edit->m_caret.UpdatePos();

  979. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  980. 	edit->InsertBreak(TRUE, TRUE);

  981. 	verify(VerifyHtml(edit, UNI_L("<div>first</div><div><br></div><div><div>inner</div></div>")));

  982. }

  983. 

  984. test("InsertBreakP_InPlainText") language C++;

  985. {

  986. 	OpDocumentEdit* edit = GetDocumentEdit();

  987. 	verify(edit);

  988. 

  989. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  990. 	// == Break without any initial P-tag =========

  991. 

  992. 	// empty

  993. 	edit->SetTextHTML(UNI_L(""));

  994. 	edit->InsertBreak(TRUE, TRUE);

  995. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P><P><BR></P>")));

  996. 	edit->InsertText(UNI_L("A"), 1);

  997. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P><P>A</P>")));

  998. 

  999. 	// before

  1000. 	edit->SetTextHTML(UNI_L("test"));

  1001. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1002. 	edit->InsertBreak(TRUE, TRUE);

  1003. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P><P>test</P>")));

  1004. 	edit->InsertText(UNI_L("A"), 1);

  1005. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P><P>Atest</P>")));

  1006. 

  1007. 	// after

  1008. 	edit->SetTextHTML(UNI_L("test"));

  1009. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1010. 	edit->InsertBreak(TRUE, TRUE);

  1011. 	verify(VerifyHtml(edit, UNI_L("<P>test</P><P><BR></P>")));

  1012. 	edit->InsertText(UNI_L("A"), 1);

  1013. 	verify(VerifyHtml(edit, UNI_L("<P>test</P><P>A</P>")));

  1014. 

  1015. 	// split

  1016. 	edit->SetTextHTML(UNI_L("test"));

  1017. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1018. 	edit->m_caret.Move(TRUE, FALSE);

  1019. 	edit->InsertBreak(TRUE, TRUE);

  1020. 	verify(VerifyHtml(edit, UNI_L("<P>t</P><P>est</P>")));

  1021. 	edit->InsertText(UNI_L("A"), 1);

  1022. 	verify(VerifyHtml(edit, UNI_L("<P>t</P><P>Aest</P>")));

  1023. #endif

  1024. }

  1025. 

  1026. test("InsertBreakP_InP") language C++;

  1027. {

  1028. 	OpDocumentEdit* edit = GetDocumentEdit();

  1029. 	verify(edit);

  1030. 

  1031. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  1032. 	// == Break with a initial P-tag =========

  1033. 

  1034. 	// before

  1035. 	edit->SetTextHTML(UNI_L("<p>test</p>"));

  1036. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1037. 	edit->InsertBreak(TRUE, TRUE);

  1038. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P><P>test</P>")));

  1039. 	edit->InsertText(UNI_L("A"), 1);

  1040. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P><P>Atest</P>")));

  1041. 

  1042. 	// after

  1043. 	edit->SetTextHTML(UNI_L("<p>test</p>"));

  1044. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1045. 	edit->InsertBreak(TRUE, TRUE);

  1046. 	verify(VerifyHtml(edit, UNI_L("<P>test</P><P><BR></P>")));

  1047. 	edit->InsertText(UNI_L("A"), 1);

  1048. 	verify(VerifyHtml(edit, UNI_L("<P>test</P><P>A</P>")));

  1049. 

  1050. 	// split

  1051. 	edit->SetTextHTML(UNI_L("<p>test</p>"));

  1052. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1053. 	edit->m_caret.Move(TRUE, FALSE);

  1054. 	edit->InsertBreak(TRUE, TRUE);

  1055. 	verify(VerifyHtml(edit, UNI_L("<P>t</P><P>est</P>")));

  1056. 	edit->InsertText(UNI_L("A"), 1);

  1057. 	verify(VerifyHtml(edit, UNI_L("<P>t</P><P>Aest</P>")));

  1058. #endif

  1059. }

  1060. 

  1061. test("InsertBreakP_InH1") language C++;

  1062. {

  1063. 	OpDocumentEdit* edit = GetDocumentEdit();

  1064. 	verify(edit);

  1065. 

  1066. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  1067. 	// == Break with a initial H1-tag =========

  1068. 

  1069. 	// before

  1070. 	edit->SetTextHTML(UNI_L("<h1>test</h1>"));

  1071. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1072. 	edit->InsertBreak(TRUE, TRUE);

  1073. //	verify(VerifyHtml(edit, UNI_L("<P><BR></P><h1>test</h1>")));

  1074. 	verify(VerifyHtml(edit, UNI_L("<h1><BR></h1><h1>test</h1>")));

  1075. 	edit->InsertText(UNI_L("A"), 1);

  1076. //	verify(VerifyHtml(edit, UNI_L("<P><BR></P><h1>Atest</h1>")));

  1077. 	verify(VerifyHtml(edit, UNI_L("<h1><BR></h1><h1>Atest</h1>")));

  1078. 

  1079. 	// after - P should follow the h1

  1080. 	edit->SetTextHTML(UNI_L("<h1>test</h1>"));

  1081. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1082. 	edit->InsertBreak(TRUE, TRUE);

  1083. 	verify(VerifyHtml(edit, UNI_L("<h1>test</h1><P><BR></P>")));

  1084. 	edit->InsertText(UNI_L("A"), 1);

  1085. 	verify(VerifyHtml(edit, UNI_L("<h1>test</h1><P>A</P>")));

  1086. 

  1087. 	// after - P should follow the h1 (with some text after the header already)

  1088. 	edit->SetTextHTML(UNI_L("<h1>test</h1>after"));

  1089. 	edit->m_caret.Place(OpWindowCommander::CARET_DOCUMENT_HOME);

  1090. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1091. 	edit->InsertBreak(TRUE, TRUE);

  1092. 	verify(VerifyHtml(edit, UNI_L("<h1>test</h1><P><BR></P>after")));

  1093. 	edit->InsertText(UNI_L("A"), 1);

  1094. 	verify(VerifyHtml(edit, UNI_L("<h1>test</h1><P>A</P>after")));

  1095. 

  1096. 	// split - new H1 should be created (instead of paragraph)

  1097. 	edit->SetTextHTML(UNI_L("<h1>test</h1>"));

  1098. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1099. 	edit->m_caret.Move(TRUE, FALSE);

  1100. 	edit->InsertBreak(TRUE, TRUE);

  1101. 	verify(VerifyHtml(edit, UNI_L("<h1>t</h1><h1>est</h1>")));

  1102. 	edit->InsertText(UNI_L("A"), 1);

  1103. 	verify(VerifyHtml(edit, UNI_L("<h1>t</h1><h1>Aest</h1>")));

  1104. #endif

  1105. }

  1106. 

  1107. test("InsertBreakP_InPRE") language C++;

  1108. {

  1109. 	OpDocumentEdit* edit = GetDocumentEdit();

  1110. 	verify(edit);

  1111. 

  1112. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  1113. 	// == Break with inside a PRE tag =========

  1114. 

  1115. 	// before

  1116. 	edit->SetTextHTML(UNI_L("<pre>test</pre>"));

  1117. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1118. 	edit->InsertBreak(TRUE, TRUE);

  1119. 	edit->InsertText(UNI_L("A"), 1);

  1120. 	verify(VerifyHtml(edit, UNI_L("<pre><br>Atest</pre>")));

  1121. 

  1122. //	Might want to change to the following behaviour

  1123. //	verify(VerifyHtml(edit, UNI_L("<pre></pre><pre>Atest</pre>")));

  1124. 

  1125. 	// after

  1126. 	edit->SetTextHTML(UNI_L("<pre>test</pre>"));

  1127. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1128. 	edit->InsertBreak(TRUE, TRUE);

  1129. 	edit->InsertText(UNI_L("A"), 1);

  1130. 	verify(VerifyHtml(edit, UNI_L("<pre>test<br>A<br></pre>")));

  1131. 

  1132. //	Might want to change to the following behaviour

  1133. //	verify(VerifyHtml(edit, UNI_L("<pre>test</pre><pre>A</pre>")));

  1134. 

  1135. 	// split - new pre should be created (instead of br)

  1136. 	edit->SetTextHTML(UNI_L("<pre>test</pre>"));

  1137. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_HOME);

  1138. 	edit->m_caret.Move(TRUE, FALSE);

  1139. 	edit->InsertBreak(TRUE, TRUE);

  1140. 	edit->InsertText(UNI_L("A"), 1);

  1141. 	verify(VerifyHtml(edit, UNI_L("<pre>t<br>Aest</pre>")));

  1142. 

  1143. //	Might want to change to the following behaviour

  1144. //	verify(VerifyHtml(edit, UNI_L("<pre>t</pre><pre>Aest</pre>")));

  1145. #endif

  1146. }

  1147. 

  1148. test("InsertBreakP_KeepStyleButNoId") language C++;

  1149. {

  1150. 	OpDocumentEdit* edit = GetDocumentEdit();

  1151. 	verify(edit);

  1152. 

  1153. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  1154. 	// == Break a P-tag with inline style and id =========

  1155. 	// The style should be set on the new P tag, but not the id.

  1156. 

  1157. 	// after

  1158. 	edit->SetTextHTML(UNI_L("<p id=\"unique\" style=\"color: red\">test</p>"));

  1159. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1160. 	edit->InsertBreak(TRUE, TRUE);

  1161. 	edit->InsertText(UNI_L("A"), 1);

  1162. 	verify(VerifyHtml(edit, UNI_L("<p id=\"unique\" style=\"color: red\">test</p><p style=\"color: red\">A</p>")));

  1163. #endif

  1164. }

  1165. 

  1166. test("RemoveContentNewAutomaticBR") language C++;

  1167. {

  1168. 	OpDocumentEdit* edit = GetDocumentEdit();

  1169. 	verify(edit);

  1170. 

  1171. #ifdef DOCUMENT_EDIT_USE_PARAGRAPH_BREAK

  1172. 	edit->SetTextHTML(UNI_L("<p>test</p>"));

  1173. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  1174. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  1175. 	verify(VerifyHtml(edit, UNI_L("<P><BR></P>")));

  1176. 

  1177. 	edit->SetTextHTML(UNI_L("<h1>test</h1>"));

  1178. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  1179. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  1180. 	verify(VerifyHtml(edit, UNI_L("<H1><BR></H1>")));

  1181. 

  1182. 	edit->SetTextHTML(UNI_L("<p>test</p>"));

  1183. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  1184. 	edit->InsertText(UNI_L("A"), 1);

  1185. 	verify(VerifyHtml(edit, UNI_L("<P>A</P>")));

  1186. 

  1187. 	edit->SetTextHTML(UNI_L("<STRONG><U>k</U></STRONG>"));

  1188. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  1189. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  1190. 	verify(VerifyHtml(edit, UNI_L("<STRONG><U><BR></U></STRONG>")));

  1191. 	edit->InsertText(UNI_L("A"), 1);

  1192. 	verify(VerifyHtml(edit, UNI_L("<STRONG><U>A</U></STRONG>")));

  1193. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  1194. 	edit->InsertText(UNI_L("B"), 1);

  1195. 	verify(VerifyHtml(edit, UNI_L("<STRONG><U>B</U></STRONG>")));

  1196. #endif

  1197. }

  1198. 

  1199. //Avoid this test temporary until selections on Containers with no VerticalLayout works (and doesn't cause asserts)

  1200. html

  1201. {

  1202. 	//! <script>

  1203. 	//! var win;

  1204. 	//! var idoc;

  1205. 	//! function do_onload()

  1206. 	//! {

  1207. 	//!   win = document.getElementById('edit').contentWindow;

  1208. 	//!   idoc = document.getElementById('edit').contentDocument;

  1209. 	//!   idoc.designMode = 'on';

  1210. 	//!   idoc.body.innerHTML = '<p></p><p>_delete_this_when_fixed_</p>';

  1211. 	//!

  1212. 	//!   var r = idoc.createRange();

  1213. 	//!   r.setStart(idoc.getElementsByTagName('p')[1], 0 );

  1214. 	//!   r.setEnd(idoc.getElementsByTagName('p')[1], 0 );

  1215. 	//!   win.getSelection().removeAllRanges();

  1216. 	//!   win.getSelection().addRange(r);

  1217. 	//!

  1218. 	//! }

  1219. 	//! </script>

  1220. 	//! <body onload="do_onload()">

  1221. 	//! <iframe id="edit" width="40" height="40"></iframe>

  1222. 	//! </body>

  1223. }

  1224. 

  1225. 

  1226. test("CaretPositionEmptyElement") language ecmascript;

  1227. {

  1228. 	verify(document.getElementById('edit').contentDocument.designMode == 'on');

  1229. 

  1230. 	idoc.execCommand('inserthtml', false, 'A');

  1231. 	verify(idoc.body.innerHTML == "<p></p><p>A_delete_this_when_fixed_</p>");

  1232. }

  1233. 

  1234. test("CaretPositionAfterLink") language C++;

  1235. {

  1236. 	OpDocumentEdit* edit = GetDocumentEdit();

  1237. 	verify(edit);

  1238. 

  1239. 	// The caret should always insert text right after a link instead of inside it (if the caret is at the last position in the link)

  1240. 

  1241. 	edit->SetTextHTML(UNI_L("<STRONG><A href=\"http://test\">test</A></STRONG>"));

  1242. 	edit->m_caret.Place(OpWindowCommander::CARET_LINE_END);

  1243. 

  1244. 	edit->InsertText(UNI_L("after"), 5);

  1245. 	verify(VerifyHtml(edit, UNI_L("<STRONG><A href=\"http://test\">test</A></STRONG>after")));

  1246. }

  1247. 

  1248. test("AlignRightAndLeft") language C++;

  1249. {

  1250. 	OpDocumentEdit* edit = GetDocumentEdit();

  1251. 	verify(edit);

  1252. 

  1253. 	edit->SetTextHTML(UNI_L("item1<p>item2</p><p align='left'>item3</p>item4"));

  1254. 

  1255. 	// Let's make everything right-aligned and verify that

  1256. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_SELECTALL);

  1257. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_JUSTIFYRIGHT);

  1258. 	verify(edit->queryCommandState(OP_DOCUMENT_EDIT_COMMAND_JUSTIFYRIGHT) == TRUE);

  1259. 	verify(edit->queryCommandState(OP_DOCUMENT_EDIT_COMMAND_JUSTIFYLEFT) == FALSE); // check so that queryCommandState works...

  1260. 

  1261. 	// And make it left-aligned and verify...

  1262. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_JUSTIFYLEFT);

  1263. 	verify(edit->queryCommandState(OP_DOCUMENT_EDIT_COMMAND_JUSTIFYRIGHT) == FALSE);

  1264. 	verify(edit->queryCommandState(OP_DOCUMENT_EDIT_COMMAND_JUSTIFYLEFT) == TRUE);

  1265. 

  1266. 	// Check so that everything really was selected

  1267. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  1268. 	verify(VerifyHtml(edit, UNI_L("<DIV align=\"left\"><BR></DIV>")));

  1269. }

  1270. 

  1271. test("InsertHrAtTopAndPlaceCaretBefore") language C++;

  1272. {

  1273. 	OpDocumentEdit* edit = GetDocumentEdit();

  1274. 	verify(edit);

  1275. 

  1276. 	edit->SetTextHTML(UNI_L(""));

  1277. 

  1278. 	// Create two HR at the top of the document and step before each of them and type text

  1279. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTHORIZONTALRULE);

  1280. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTHORIZONTALRULE);

  1281. 	verify(VerifyHtml(edit, UNI_L("<HR><HR>")));

  1282. 	edit->m_caret.Move(FALSE,FALSE);

  1283. 	edit->InsertText(UNI_L("b"), 1);

  1284. 	edit->m_caret.Move(FALSE,FALSE);

  1285. 	edit->m_caret.Move(FALSE,FALSE);

  1286. 	edit->InsertText(UNI_L("a"), 1);

  1287. 	verify(VerifyHtml(edit, UNI_L("a<HR>b<HR>")));

  1288. }

  1289. 

  1290. test("IME_accepted") language C++;

  1291. require WIDGETS_IME_SUPPORT;

  1292. {

  1293. 	OpDocumentEdit* edit = GetDocumentEdit();

  1294. 	verify(edit);

  1295. 

  1296. 	edit->SetTextHTML(UNI_L(""));

  1297. 

  1298. 	OpInputMethodString imstring;

  1299. 	imstring.Set(UNI_L("test1"), 5);

  1300. 

  1301. 	edit->OnStartComposing(&imstring, IM_COMPOSE_NEW);

  1302. 	verify(VerifyHtml(edit, UNI_L("<BR>")));

  1303. 

  1304. 	edit->OnCompose();

  1305. 	verify(VerifyHtml(edit, UNI_L("test1")));

  1306. 

  1307. 	imstring.Set(UNI_L("test2"), 5);

  1308. 	edit->OnCompose();

  1309. 	verify(VerifyHtml(edit, UNI_L("test2")));

  1310. 

  1311. 	edit->OnStopComposing(FALSE);

  1312. 	verify(VerifyHtml(edit, UNI_L("test2")));

  1313. }

  1314. 

  1315. test("IME_canceled") language C++;

  1316. require WIDGETS_IME_SUPPORT;

  1317. {

  1318. 	OpDocumentEdit* edit = GetDocumentEdit();

  1319. 	verify(edit);

  1320. 

  1321. 	edit->SetTextHTML(UNI_L(""));

  1322. 

  1323. 	OpInputMethodString imstring;

  1324. 	imstring.Set(UNI_L("test1"), 5);

  1325. 

  1326. 	edit->OnStartComposing(&imstring, IM_COMPOSE_NEW);

  1327. 

  1328. 	edit->OnCompose();

  1329. 	verify(VerifyHtml(edit, UNI_L("test1")));

  1330. 

  1331. 	edit->OnStopComposing(TRUE);

  1332. 	verify(VerifyHtml(edit, UNI_L("")));

  1333. }

  1334. 

  1335. test("IME_pending_styles") language C++;

  1336. require WIDGETS_IME_SUPPORT;

  1337. {

  1338. 	OpDocumentEdit* edit = GetDocumentEdit();

  1339. 	verify(edit);

  1340. 

  1341. 	edit->SetTextHTML(UNI_L(""));

  1342. 

  1343. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BOLD);

  1344. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_ITALIC);

  1345. 

  1346. 	OpInputMethodString imstring;

  1347. 	imstring.Set(UNI_L("test"), 4);

  1348. 

  1349. 	edit->OnStartComposing(&imstring, IM_COMPOSE_NEW);

  1350. 	edit->OnCompose();

  1351. 	verify(VerifyHtml(edit, UNI_L("<EM><STRONG>test</STRONG></EM>")));

  1352. 	edit->OnCompose();

  1353. 	verify(VerifyHtml(edit, UNI_L("<EM><STRONG>test</STRONG></EM>")));

  1354. 

  1355. 	edit->OnStopComposing(FALSE);

  1356. 	verify(VerifyHtml(edit, UNI_L("<EM><STRONG>test</STRONG></EM>")));

  1357. }

  1358. 

  1359. test("DefaultBlock div") language C++;

  1360. {

  1361. 	OpDocumentEdit* edit = GetDocumentEdit();

  1362. 	verify(edit);

  1363. 

  1364. 	OpInputAction enter(OpInputAction::ACTION_LOWLEVEL_KEY_PRESSED, OP_KEY_ENTER);

  1365. 	OpInputAction b(OpInputAction::ACTION_LOWLEVEL_KEY_PRESSED, OP_KEY_B);

  1366. 	verify_success(b.SetActionKeyValue("b", 1));

  1367. 

  1368. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DEFAULT_BLOCK, FALSE, UNI_L("div"));

  1369. 

  1370. 	edit->SetTextHTML(UNI_L("a"));

  1371. 	edit->m_caret.Place(OpWindowCommander::CARET_DOCUMENT_END);

  1372. 

  1373. 	edit->EditAction(&enter);

  1374. 	verify(VerifyHtml(edit, UNI_L("<div>a</div><div><br></div>")));

  1375. 

  1376. 	edit->EditAction(&b);

  1377. 	verify(VerifyHtml(edit, UNI_L("<div>a</div><div>b</div>")));

  1378. 

  1379. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DEFAULT_BLOCK, FALSE, UNI_L("p"));

  1380. }

  1381. 

  1382. test("DefaultBlock insert paragraph") language C++;

  1383. {

  1384. 	OpDocumentEdit* edit = GetDocumentEdit();

  1385. 	verify(edit);

  1386. 

  1387. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DEFAULT_BLOCK, FALSE, UNI_L("div"));

  1388. 

  1389. 	edit->SetTextHTML(UNI_L("a"));

  1390. 	edit->m_caret.Place(OpWindowCommander::CARET_DOCUMENT_END);

  1391. 

  1392. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTPARAGRAPH);

  1393. 	verify(VerifyHtml(edit, UNI_L("<div>a</div><div><br></div>")));

  1394. 

  1395. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DEFAULT_BLOCK, FALSE, UNI_L("p"));

  1396. }

  1397. 

  1398. test("DefaultBlock div with lists") language C++;

  1399. {

  1400. 	OpDocumentEdit* edit = GetDocumentEdit();

  1401. 	verify(edit);

  1402. 

  1403. 	OpInputAction enter(OpInputAction::ACTION_LOWLEVEL_KEY_PRESSED, OP_KEY_ENTER);

  1404. 	OpInputAction b(OpInputAction::ACTION_LOWLEVEL_KEY_PRESSED, OP_KEY_B);

  1405. 	OpInputAction backspace(OpInputAction::ACTION_BACKSPACE);

  1406. 	verify_success(b.SetActionKeyValue("b", 1));

  1407. 

  1408. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DEFAULT_BLOCK, FALSE, UNI_L("div"));

  1409. 

  1410. 	edit->SetTextHTML(UNI_L("a"));

  1411. 	edit->m_caret.Place(OpWindowCommander::CARET_DOCUMENT_END);

  1412. 

  1413. 	edit->EditAction(&enter);

  1414. 	verify(VerifyHtml(edit, UNI_L("<div>a</div><div><br></div>")));

  1415. 

  1416. 	edit->EditAction(&backspace);

  1417. 	verify(VerifyHtml(edit, UNI_L("<div>a</div>")));

  1418. 

  1419. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTUNORDEREDLIST);

  1420. 	verify(VerifyHtml(edit, UNI_L("<ul><li>a</li></ul>")));

  1421. 

  1422. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTUNORDEREDLIST);

  1423. 	verify(VerifyHtml(edit, UNI_L("<div>a</div>")));

  1424. 

  1425. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTUNORDEREDLIST);

  1426. 	verify(VerifyHtml(edit, UNI_L("<ul><li>a</li></ul>")));

  1427. 

  1428. 	edit->EditAction(&enter);

  1429. 	verify(VerifyHtml(edit, UNI_L("<ul><li>a</li><li></li></ul>")));

  1430. 

  1431. 	edit->EditAction(&enter);

  1432. 	verify(VerifyHtml(edit, UNI_L("<ul><li>a</li></ul><div></div>")));

  1433. 

  1434. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DEFAULT_BLOCK, FALSE, UNI_L("p"));

  1435. }

  1436. 

  1437. html

  1438. {

  1439. //! <body onload="document.getElementsByTagName('div')[0].focus();"><ul><li><div contenteditable="true"></div></ul></body>

  1440. }

  1441. 

  1442. test("ContentEditable within list item")

  1443. {

  1444. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1445. 	verify(edit);

  1446. 

  1447. 	// Document edit adds the <br> inside the div automatically.

  1448. 	// Also, newline is for some reason necessary at the end.

  1449. 	VerifyHtml(edit, UNI_L("<ul><li><div contenteditable=\"true\"><br></div></li></ul>\n"));

  1450. 

  1451. 	edit->InsertBreak();

  1452. 	VerifyHtml(edit, UNI_L("<ul><li><div contenteditable=\"true\"><br><br></div></li></ul>\n"));

  1453. }

  1454. 

  1455. html

  1456. {

  1457. 	//! <body>

  1458. 	//! <div contenteditable="TRUE"></div>

  1459. 	//! </body>

  1460. }

  1461. 

  1462. 

  1463. test("ContentEditable_Simple") language C++;

  1464. {

  1465. 	if (state.doc)

  1466. 		verify(state.doc->GetDocumentEdit());

  1467. }

  1468. 

  1469. html

  1470. {

  1471. 	//! <body>

  1472. 	//! <div id="one" contenteditable="TRUE"></div>

  1473. 	//! <script>

  1474. 	//!     document.getElementById('one').focus();

  1475. 	//!     document.execCommand("insertHTML", false, "PASS");

  1476. 	//! </script>

  1477. 	//! </body>

  1478. }

  1479. 

  1480. test("ContentEditable_ScriptAfter") language ecmascript;

  1481. {

  1482. 	/* This is not completely compatible with other browsers

  1483. 	   since they seem to require that we wait until the

  1484. 	   entire page is loaded before enabling designmode.

  1485. 	   not sure how important or good it is to implement this */

  1486. 	var one = document.getElementById("one");

  1487. 	verify(one.firstChild.data=='PASS');

  1488. }

  1489. 

  1490. 

  1491. html

  1492. {

  1493. 	//! <body>PASS<div id="one" contenteditable="TRUE">PASS<script>

  1494. 	//!     document.execCommand("insertHTML", false, "FAIL");

  1495. 	//! </script>

  1496. 	//! </div>

  1497. 	//! </body>

  1498. }

  1499. 

  1500. test("ContentEditable_ScriptInside") language ecmascript;

  1501. {

  1502. 	/* If we enable designmode as an emergency resort to handle

  1503. 	   the execCommand, the added code end up as a child of body

  1504. 	   instead of as a child of the documenteditable.

  1505. 	   Generally the execCommand should not run at all before

  1506. 	   the contenteditable is enabled. Related to DSK-153397. */

  1507. 

  1508. 	var one = document.getElementById("one");

  1509. 	verify(one.firstChild.data=='PASS');

  1510. 	var body = document.getElementsByTagName("body")[0];

  1511. 	verify(body.firstChild.data == 'PASS');

  1512. }

  1513. 

  1514. html

  1515. {

  1516. 	//! <body>PASS<div>dummy</div>

  1517. 	//! </body>

  1518. }

  1519. 

  1520. test("ContentEditable_ExecCommandNoEditable") language ecmascript;

  1521. {

  1522. 	/* execCommand on a non-editable document should not

  1523. 	throw an exception. And not insert anything. See also DSK-153397. */

  1524. 

  1525. 	try

  1526. 	{

  1527. 		document.execCommand("insertHTML", false, "FAIL");

  1528. 	}

  1529. 	catch (err)

  1530. 	{

  1531. 		verify(0);

  1532. 	}

  1533. 	var body = document.getElementsByTagName("body")[0];

  1534. 	verify(body.firstChild.data == 'PASS');

  1535. }

  1536. 

  1537. html

  1538. {

  1539. 	//! <!DOCTYPE html><html><head><title>appending contenteditable element</title>

  1540. 	//! </head><body></body></html>

  1541. 

  1542. }

  1543. 

  1544. test("Inserting contenteditable should only create br if needed")

  1545. language ecmascript;

  1546. {

  1547. 	var node1 = document.createElement('div');

  1548. 	node1.contentEditable = 'true';

  1549. 	node1.innerHTML = 'text';

  1550. 

  1551. 	node1.style.display = 'none';

  1552. 	document.body.appendChild(node1);

  1553. 	node1.style.display = 'block';

  1554. 

  1555. 	verify(node1.innerHTML=='text');

  1556. }

  1557. 

  1558. html

  1559. {

  1560. 	//! <!DOCTYPE html>

  1561. 	//! <title>Missing trailing linebreak</title>

  1562. 	//! <body contenteditable>

  1563. 	//! <pre>X<br></pre></body>

  1564. }

  1565. 

  1566. test("Pasting text with linebreak")

  1567. {

  1568. 	HTML_Element* pre = find_element("pre");

  1569. 	verify(pre);

  1570. 	// Caret between text node and <br>

  1571. 	SelectionBoundaryPoint start(pre, 1);

  1572. 	SelectionBoundaryPoint end(pre, 1);

  1573. 

  1574. 	state.doc->GetHtmlDocument()->SetSelection(&start, &end);

  1575. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1576. 	verify(edit);

  1577. 	const uni_char* clipboard_text = UNI_L("foo\n");

  1578. 	verify_success(edit->InsertText(clipboard_text, 4)); // The function used by OpDocumentEdit::OnPaste().

  1579. 	verify_success(edit->InsertText(clipboard_text, 4)); // The function used by OpDocumentEdit::OnPaste().

  1580. 	HTML_Element* pre_child = pre->FirstChildActual();

  1581. 	verify(pre_child && pre_child->Type() == HE_TEXT); // "X"

  1582. 	pre_child = pre_child->SucActual();

  1583. 	verify(pre_child && pre_child->Type() == HE_TEXT); // "foo"

  1584. 	pre_child = pre_child->SucActual();

  1585. 	verify(pre_child && pre_child->IsMatchingType(HE_BR, NS_HTML)); // <br>

  1586. 	pre_child = pre_child->SucActual();

  1587. 	verify(pre_child && pre_child->Type() == HE_TEXT); // "foo"

  1588. 	pre_child = pre_child->SucActual();

  1589. 	verify(pre_child && pre_child->IsMatchingType(HE_BR, NS_HTML)); // <br>

  1590. 	pre_child = pre_child->SucActual();

  1591. 	verify(pre_child && pre_child->IsMatchingType(HE_BR, NS_HTML)); // <br>

  1592. 	pre_child = pre_child->SucActual();

  1593. 	verify(!pre_child);

  1594. }

  1595. 

  1596. html

  1597. {

  1598. 	"<body><p></p><div contentEditable=true><input></div></body>"

  1599. }

  1600. test("Replace clicked input with text") language C++;

  1601. {

  1602. 	// Was a crasher (CORE-24156).

  1603. 

  1604. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1605. 	verify(edit);

  1606. 

  1607. 	// simulate a mouse click on the input

  1608. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, find_element("input"), NULL, 127, 8, 138, 19, 0, 98304);

  1609. 

  1610. 	edit->InsertText(UNI_L("a"), 1); // shouldn't crash here

  1611. 

  1612. 	verify(VerifyHtml(edit, UNI_L("<P></P><DIV contenteditable=\"true\">a</DIV>")));

  1613. }

  1614. 

  1615. html

  1616. {

  1617. 	"<body><p></p><div contentEditable=true><input></div></body>"

  1618. }

  1619. test("Remove last input element from contentEditable element") language C++;

  1620. {

  1621. 	// When the input is removed the div shouldn't dissapear, a <br> placeholder should be inserted instead.

  1622. 

  1623. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1624. 	verify(edit);

  1625. 

  1626. 	// simulate a mouse click on the input

  1627. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, find_element("input"), NULL, 127, 8, 138, 19, 0, 98304);

  1628. 

  1629. 	OpInputAction backspace(OpInputAction::ACTION_BACKSPACE);

  1630. 

  1631. 	edit->OnInputAction(&backspace);

  1632. 

  1633. 	verify(VerifyHtml(edit, UNI_L("<P></P><DIV contenteditable=\"true\"><BR></DIV>")));

  1634. }

  1635. 

  1636. setup

  1637. {

  1638. }

  1639. 

  1640. exit

  1641. {

  1642. }

  1643. 

  1644. // CORE-25307

  1645. html

  1646. {

  1647. //! <!DOCTYPE html>

  1648. //! <html>

  1649. //! <head>

  1650. //!   <title>appendChild, queryCommandState and selection</title>

  1651. //!   <style type="text/css"> body { margin: 0; } </style>

  1652. //!   <script type="text/javascript">

  1653. //!       // Code here comes from TinyMCE 3.

  1654. //!       // (stripped down)

  1655. //!       function getSelectedNode() {

  1656. //!         var s = window.getSelection(), r = null, e = null;

  1657. //!         if (s && s.rangeCount > 0) {

  1658. //!           r = s.getRangeAt(0);

  1659. //!         } else {

  1660. //!           r = s && s.createRange ? s.createRange() : document.createRange();

  1661. //!         }

  1662. //!

  1663. //!         var e = r.commonAncestorContainer;

  1664. //!

  1665. //!         if (!r.collapsed) {

  1666. //!           if (r.startContainer == r.endContainer) {

  1667. //!             if (r.startOffset - r.endOffset < 2) {

  1668. //!               if (r.startContainer.hasChildNodes()) {

  1669. //!                 e = r.startContainer.childNodes[r.startOffset];

  1670. //!               }

  1671. //!             }

  1672. //!           }

  1673. //!         }

  1674. //!

  1675. //!         if (e.nodeType !== Node.ELEMENT_NODE) {

  1676. //!           e = e.parentNode;

  1677. //!         }

  1678. //!

  1679. //!         return e;

  1680. //!       }

  1681. //!

  1682. //!       function handler(ev) {

  1683. //!         var results = document.getElementById('results');

  1684. //!         results.innerHTML = 'IN PROGRESS';

  1685. //!         document.queryCommandState('bold');

  1686. //!         var node = getSelectedNode();

  1687. //!         results.innerHTML = (node instanceof HTMLImageElement ? 'PASS' : 'FAIL');

  1688. //!       }

  1689. //!   </script>

  1690. //! </head>

  1691. //! <body>

  1692. //!   <p contentEditable="true"><img src="http://t/resources/images/100x100-navy.png" id="test" onclick="handler()"></p>

  1693. //!

  1694. //!   <p id="results">NOT TESTED</p>

  1695. //! </body>

  1696. //! </html>

  1697. }

  1698. test("selection after queryCommandState - setup1")

  1699. {

  1700. 	HTML_Element* img = find_element("img");

  1701. 	verify(img);

  1702. 	// simulate a mouse click on the image

  1703. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, img, NULL, 35, 33, 35, 49, 0, 98304);

  1704. 	state.doc->HandleMouseEvent(ONMOUSEUP,   NULL, img, NULL, 35, 33, 35, 49, 0, 98304);

  1705. }

  1706. test("selection after queryCommandState - setup2")

  1707. language ecmascript;

  1708. require success "selection after queryCommandState - setup1";

  1709. {

  1710. 	// nothing - just to make sure onclick script has run

  1711. }

  1712. test("selection after queryCommandState")

  1713. require success "selection after queryCommandState - setup2";

  1714. {

  1715. 	// find output element

  1716. 	HTML_Element* p = find_element("p", 2);

  1717. 	verify(p && p->Type() == HE_P);

  1718. 	// check contents - should be "PASS"

  1719. 	const int len = 4;

  1720. 	uni_char buf[len+1];					/* ARRAY OK 2010-06-07 markuso */

  1721. 	verify(p->GetTextContent(buf, len+1) == len);

  1722. 	verify(!uni_strcmp(buf, "PASS"));

  1723. }

  1724. 

  1725. html

  1726. {

  1727. 	//!<html>

  1728. 	//!<head>

  1729. 	//!<style>

  1730. 	//!body { height: 50px; }

  1731. 	//!</style>

  1732. 	//!</head>

  1733. 	//!<body contenteditable=true>

  1734. 	//!<div>a</div>

  1735. 	//!</body>

  1736. 	//!</html>

  1737. }

  1738. test("Caret place end")

  1739. {

  1740. 	verify(state.doc);

  1741. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1742. 	verify(edit);

  1743. 

  1744. 	edit->m_caret.Place(OpWindowCommander::CARET_DOCUMENT_HOME);

  1745. 	edit->m_caret.Place(OpWindowCommander::CARET_DOCUMENT_END);

  1746. 	edit->InsertText(UNI_L("b"), 1);

  1747. 	HTML_Element* div = find_element("div");

  1748. 	verify(div && div->Type() == HE_DIV);

  1749. 	verify(div->FirstChild() == edit->m_caret.GetElement());

  1750. 	verify(div->GetTextContentLength() == 2);

  1751. 	uni_char buf[3];						/* ARRAY OK 2010-06-07 markuso */

  1752. 	verify(div->GetTextContent(buf, 3));

  1753. 	verify(uni_strcmp(buf, UNI_L("ab")) == 0);

  1754. }

  1755. 

  1756. html

  1757. {

  1758. 	//!<html>

  1759. 	//!<head>

  1760. 	//!</head>

  1761. 	//!<body contenteditable=true>

  1762. 	//!</body>

  1763. 	//!</html>

  1764. }

  1765. 

  1766. test("Catching HTML_Element's Next() - NextActual() usage mismatch in UNDO/REDO stack #1") language C++;

  1767. {

  1768. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1769. 	verify(edit);

  1770. 

  1771. 	edit->SetTextHTML(UNI_L("<DIV STYLE=\"DISPLAY:TABLE-CELL\">DIV DISPLAYED AS TABLE CELL</DIV><P>Some text inside P element</P><DIV STYLE=\"DISPLAY:TABLE-CELL\">DIV DISPLAYED AS TABLE CELL</DIV>"));

  1772. 

  1773. 	HTML_Element *p = edit->GetBody()->FirstChild()->SucActual();

  1774. 	verify(p->Type() == HE_P);

  1775. 	HTML_Element* elm = edit->FindEditableElement(p, TRUE, TRUE, FALSE);

  1776. 	verify(elm);

  1777. 	edit->m_caret.Place(elm, 0);

  1778. 	edit->m_selection.SelectToCaret(edit->m_caret.GetElement(), 5);

  1779. 

  1780. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_DELETE);

  1781. 	verify(VerifyHtml(edit, UNI_L("<DIV STYLE=\"DISPLAY:TABLE-CELL\">DIV DISPLAYED AS TABLE CELL</DIV><P>text inside P element</P><DIV STYLE=\"DISPLAY:TABLE-CELL\">DIV DISPLAYED AS TABLE CELL</DIV>")));

  1782. 

  1783. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  1784. 	verify(VerifyHtml(edit, UNI_L("<DIV STYLE=\"DISPLAY:TABLE-CELL\">DIV DISPLAYED AS TABLE CELL</DIV><P>Some text inside P element</P><DIV STYLE=\"DISPLAY:TABLE-CELL\">DIV DISPLAYED AS TABLE CELL</DIV>")));

  1785. }

  1786. 

  1787. test("Catching HTML_Element's Next() - NextActual() usage mismatch in UNDO/REDO stack #2") language C++;

  1788. {

  1789. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1790. 	verify(edit);

  1791. 

  1792. 	edit->SetTextHTML(UNI_L("<div>A<div style=\"display:table-cell\"><div>B</div><div>C</div></div></div><div>D</div>"));

  1793. 

  1794. 	HTML_Element *div = edit->GetBody()->FirstChildActual();

  1795. 	verify(div->Type() == HE_DIV);

  1796. 	HTML_Element* elm = edit->FindEditableElement(div, TRUE, TRUE, FALSE);

  1797. 	verify(elm);

  1798. 	edit->m_caret.Place(elm, 0);

  1799. 

  1800. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_BACKCOLOR, FALSE, UNI_L("red"));

  1801. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  1802. 	verify(VerifyHtml(edit, UNI_L("<div>A<div style=\"display:table-cell\"><div>B</div><div>C</div></div></div><div>D</div>")));

  1803. }

  1804. 

  1805. html

  1806. {

  1807. 	//!<doctype html>

  1808. 	//!<html>

  1809. 	//!<head>

  1810. 	//!<style>

  1811. 	//!* { margin:0; padding:0; line-height:20px; }

  1812. 	//!</style>

  1813. 	//!</head>

  1814. 	//!<body contenteditable=true><b>abc<b><br><br></body>

  1815. 	//!</html>

  1816. }

  1817. test("Place caret after text row ending with br") language C++;

  1818. {

  1819. 	/* Verify that the caret is placed at the last content of the line when the mouse

  1820. 	   is clicked to the right of that line. CORE-30815. */

  1821. 

  1822. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1823. 	verify(edit);

  1824. 

  1825. 	/* Simulate a mouse click to the right of the "abc<br>" line. */

  1826. 

  1827. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, find_element("body"), NULL, 200, 10, 200, 10, 0, 98304);

  1828. 	state.doc->HandleMouseEvent(ONMOUSEUP, NULL, find_element("body"), NULL, 200, 10, 200, 10, 0, 98304);

  1829. 

  1830. 	HTML_Element* caret_elm = edit->m_caret.GetElement();

  1831. 

  1832. 	verify(caret_elm);

  1833. 

  1834. 	verify(caret_elm->IsText());

  1835. 

  1836. 	const uni_char* text = caret_elm->TextContent();

  1837. 

  1838. 	verify(uni_strncmp(text, UNI_L("abc"), 3) == 0);

  1839. }

  1840. 

  1841. 

  1842. html

  1843. {

  1844. 	//!<doctype html>

  1845. 	//!<html>

  1846. 	//!<head>

  1847. 	//!<style>

  1848. 	//!* { margin:0; padding:0; line-height:20px; }

  1849. 	//!</style>

  1850. 	//!</head>

  1851. 	//!<body contenteditable=true><b>abc<img src="data:image/png;base64,

  1852. 	//!iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAABGdBTUEAALGP

  1853. 	//!C/xhBQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9YGARc5KB0XV+IA

  1854. 	//!AAAddEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIFRoZSBHSU1Q72QlbgAAAF1J

  1855. 	//!REFUGNO9zL0NglAAxPEfdLTs4BZM4DIO4C7OwQg2JoQ9LE1exdlYvBBeZ7jq

  1856. 	//!ch9//q1uH4TLzw4d6+ErXMMcXuHWxId3KOETnnXXV6MJpcq2MLaI97CER3N0

  1857. 	//!vr4MkhoXe0rZigAAAABJRU5ErkJggg==">

  1858. 	//!<img src="data:image/png;base64,

  1859. 	//!iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAABGdBTUEAALGP

  1860. 	//!C/xhBQAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9YGARc5KB0XV+IA

  1861. 	//!AAAddEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIFRoZSBHSU1Q72QlbgAAAF1J

  1862. 	//!REFUGNO9zL0NglAAxPEfdLTs4BZM4DIO4C7OwQg2JoQ9LE1exdlYvBBeZ7jq

  1863. 	//!ch9//q1uH4TLzw4d6+ErXMMcXuHWxId3KOETnnXXV6MJpcq2MLaI97CER3N0

  1864. 	//!vr4MkhoXe0rZigAAAABJRU5ErkJggg=="></b><br><br></body>

  1865. 	//!</html>

  1866. }

  1867. test("Place caret after image row ending with br") language C++;

  1868. {

  1869. 	/* Verify that the caret is placed at the last content of the line when the mouse

  1870. 	   is clicked to the right of that line. CORE-30815. */

  1871. 

  1872. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1873. 	verify(edit);

  1874. 

  1875. 	/* Simulate a mouse click to the right of the line with content */

  1876. 

  1877. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, find_element("body"), NULL, 200, 10, 200, 10, 0, 98304);

  1878. 	state.doc->HandleMouseEvent(ONMOUSEUP, NULL, find_element("body"), NULL, 200, 10, 200, 10, 0, 98304);

  1879. 

  1880. 	HTML_Element* caret_elm = edit->m_caret.GetElement();

  1881. 

  1882. 	verify(caret_elm);

  1883. 

  1884. 	verify(caret_elm->IsMatchingType(HE_IMG, NS_HTML));

  1885. 

  1886. 	verify(caret_elm->Pred());

  1887. 

  1888. 	verify(caret_elm->Pred()->IsText());

  1889. }

  1890. 

  1891. html

  1892. {

  1893. 	//! <html>

  1894. 	//! <head contenteditable="true">abc</head>

  1895. 	//! <body>

  1896. 	//! </body>

  1897. 	//! </html>

  1898. }

  1899. test("HEAD should not be editable")

  1900. {

  1901. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1902. 	verify(!edit || !edit->m_caret.GetElement());

  1903. 

  1904. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, find_element("html"), NULL, 100, 100, 100, 100, 0, 98304);

  1905. 	state.doc->HandleMouseEvent(ONMOUSEUP, NULL, find_element("html"), NULL, 100, 100, 100, 100, 0, 98304);

  1906. 

  1907. 	edit = state.doc->GetDocumentEdit();

  1908. 	verify(!edit || !edit->m_caret.GetElement());

  1909. }

  1910. 

  1911. html

  1912. {

  1913. 	//! <html>

  1914. 	//! <body>

  1915. 	//! </body>

  1916. 	//! </html>

  1917. }

  1918. test("HELPER: set contentEditable on HTML and recreate body")

  1919. 	language ecmascript;

  1920. {

  1921. 	/* This is not an actual test, just part of a setup that

  1922. 	   is easiest to be written in EcmaScript */

  1923. 	var html = document.documentElement

  1924. 	html.removeChild(document.querySelector('body'))

  1925. 

  1926. 	html.contentEditable = true

  1927. 	html.appendChild(document.createElement('body'))

  1928. }

  1929. 

  1930. test("Content editable on HTML element focuses <body>")

  1931. 	require success "HELPER: set contentEditable on HTML and recreate body";

  1932. {

  1933. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1934. 	verify(edit);

  1935. 	verify(!(edit->m_caret.GetElement()));

  1936. 

  1937. 	state.doc->HandleMouseEvent(ONMOUSEDOWN, NULL, find_element("html"), NULL, 100, 100, 100, 100, 0, 98304);

  1938. 	state.doc->HandleMouseEvent(ONMOUSEUP, NULL, find_element("html"), NULL, 100, 100, 100, 100, 0, 98304);

  1939. 

  1940. 	edit = state.doc->GetDocumentEdit();

  1941. 	verify(edit);

  1942. 	verify(edit->m_caret.GetElement());

  1943. 

  1944. 	HTML_Element* caret_element_parent = edit->m_caret.GetElement()->ParentActual();

  1945. 	verify(caret_element_parent);

  1946. 	verify(caret_element_parent->IsMatchingType(HE_BODY, NS_HTML));

  1947. }

  1948. 

  1949. html

  1950. {

  1951. 	//! <html>

  1952. 	//! <style>div { display: table-cell; }</style>

  1953. 	//! <body contentEditable="true"><div></div><p>PASS</p></body>

  1954. 	//! </html>

  1955. }

  1956. test("Generated content vs lists")

  1957. {

  1958. 	// We need to try and insert a list after some content inserted by layout

  1959. 	// The div with display: table-cell ensures layout will insert some table

  1960. 	// elements

  1961. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1962. 	verify(edit);

  1963. 

  1964. 	verify(VerifyHtml(edit, UNI_L("<div></div><p>PASS</p>\n\n")));

  1965. 	edit->m_caret.Place(edit->FindElementAfterOfType(edit->GetBody(), HE_P, FALSE), 4);

  1966. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTUNORDEREDLIST);

  1967. 	verify(VerifyHtml(edit, UNI_L("<div></div><ul><li>PASS</li></ul>\n\n")));

  1968. 	edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_INSERTUNORDEREDLIST);

  1969. 	// document edit likes to add paragraphs but the important thing is

  1970. 	// that the list is created and removed and there is no crash.

  1971. 	verify(VerifyHtml(edit, UNI_L("<div></div><p>PASS</p>\n\n")));

  1972. }

  1973. 

  1974. html

  1975. {

  1976. 	//! <!DOCTYPE html>

  1977. 	//! <title>focus not updated when inserting newline</title>

  1978. 	//! <body contenteditable>

  1979. 	//! <pre>Click after the end of this line and press enter.<br/>A new line should be inserted with caret in that line.

  1980. 	//! (If the caret remains at the end of the first line it is a fail). </pre>

  1981. 	//! </body>

  1982. }

  1983. 

  1984. test("Pressing enter at the end of a line with br")

  1985. {

  1986. 	HTML_Element* pre = find_element("pre");

  1987. 	verify(pre);

  1988. 	// Caret between text node and <br>.

  1989. 	SelectionBoundaryPoint start(pre, 1);

  1990. 	SelectionBoundaryPoint end(pre, 1);

  1991. 	state.doc->GetHtmlDocument()->SetSelection(&start, &end);

  1992. 	verify(state.doc->GetCaretPainter());

  1993. 	int before_y = state.doc->GetCaretPainter()->GetY();

  1994. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  1995. 	verify(edit);

  1996. 	edit->InsertBreak(TRUE, TRUE);

  1997. 	int after_y = state.doc->GetCaretPainter()->GetY();

  1998. 	verify(after_y > before_y || !"The caret didn't move to the next line");

  1999. }

  2000. 

  2001. html

  2002. {

  2003. 	"<html>"

  2004. 	"<body contentEditable=\"true\"><p id=\"foo\">FAIL: JavaScript not run</p></body>"

  2005. 	"</html>"

  2006. }

  2007. test("Caret moving through non-BMP characters: setup")

  2008. 	language ecmascript;

  2009. {

  2010. 	// Until html{} learns how to insert non-ASCII characters...

  2011. 	var p = document.getElementById("foo");

  2012. 	p.innerHTML = "Z\uD800\uDC00Z";

  2013. }

  2014. test("Caret moving through non-BMP characters")

  2015. 	require success "Caret moving through non-BMP characters: setup";

  2016. {

  2017. 	// We must not have the caret placed inside a surrogate pair

  2018. 	// (CORE-20881).

  2019. 	OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  2020. 	verify(edit);

  2021. 	verify(VerifyHtml(edit, UNI_L("<p id=\"foo\">Z\xD800\xDC00Z</p>")));

  2022. 

  2023. 	edit->m_caret.Place(edit->FindElementAfterOfType(edit->GetBody(), HE_P, FALSE), 0);

  2024. 	verify(edit->m_caret.GetOffset() == 0);

  2025. 	edit->m_caret.Move(TRUE, FALSE);

  2026. 	verify(edit->m_caret.GetOffset() == 1);

  2027. 

  2028. 	// Next move should skip past the entire non-BMP character

  2029. 	edit->m_caret.Move(TRUE, FALSE);

  2030. 	verify(edit->m_caret.GetOffset() == 3);

  2031. 

  2032. 	// Moving back should put us before the non-BMP character again

  2033. 	edit->m_caret.Move(FALSE, FALSE);

  2034. 	verify(edit->m_caret.GetOffset() == 1);

  2035. }

  2036. 

  2037. table converthextounicode

  2038. {

  2039. 	{ "BMP",      "20AC",   UNI_L("<p>20AC</p>"),   UNI_L("<p>\x20AC</p>")       },

  2040. 	{ "non-BMP",  "1D616",  UNI_L("<p>1D616</p>"),  UNI_L("<p>\xD835\xDE16</p>") },

  2041. 	{ "partial",  "XXX58",  UNI_L("<p>XXX58</p>"),  UNI_L("<p>XXXX</p>")         },

  2042. 	{ "overlong", "200032", UNI_L("<p>200032</p>"), UNI_L("<p>202</p>")          },

  2043. }

  2044. foreach (name, content, original, converted) from converthextounicode

  2045. {

  2046. 	html

  2047. 	{

  2048. 		"<html>"

  2049. 		"<body contentEditable=\"true\"><p>"

  2050. 		content

  2051. 		"</p></body>"

  2052. 		"</html>"

  2053. 	}

  2054. 	test("Convert hex to Unicode: " name)

  2055. 	{

  2056. 		OpDocumentEdit* edit = state.doc->GetDocumentEdit();

  2057. 		verify(edit);

  2058. 		verify(VerifyHtml(edit, original));

  2059. 

  2060. 		OpInputAction convert(OpInputAction::ACTION_CONVERT_HEX_TO_UNICODE);

  2061. 

  2062. 		edit->m_caret.Place(edit->FindElementAfterOfType(edit->GetBody(), HE_P, FALSE), op_strlen(content));

  2063. 		edit->EditAction(&convert);

  2064. 		verify(VerifyHtml(edit, converted));

  2065. 

  2066. 		edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_UNDO);

  2067. 		verify(VerifyHtml(edit, original));

  2068. 

  2069. 		edit->execCommand(OP_DOCUMENT_EDIT_COMMAND_REDO);

  2070. 		verify(VerifyHtml(edit, converted));

  2071. 	}

  2072. }

  2073. 

  2074. html

  2075. {

  2076. 	//! <script>

  2077. 	//! var win;

  2078. 	//! var idoc;

  2079. 	//! function do_onload()

  2080. 	//! {

  2081. 	//!   win = document.getElementById('edit').contentWindow;

  2082. 	//!   idoc = document.getElementById('edit').contentDocument;

  2083. 	//!   idoc.designMode = 'on';

  2084. 	//!   idoc.body.innerHTML = '<div></div>';

  2085. 	//!

  2086. 	//!   var r = idoc.createRange();

  2087. 	//!   r.setStart(idoc.getElementsByTagName('div')[0], 0 );

  2088. 	//!   r.setEnd(idoc.getElementsByTagName('div')[0], 0 );

  2089. 	//!   win.getSelection().removeAllRanges();

  2090. 	//!   win.getSelection().addRange(r);

  2091. 	//!

  2092. 	//! }

  2093. 	//! </script>

  2094. 	//! <body onload="do_onload()">

  2095. 	//! <iframe id="edit" width="40" height="40"></iframe>

  2096. 	//! </body>

  2097. }

  2098. 

  2099. 

  2100. test("Caret position set from DOM on non text element in text container") language ecmascript;

  2101. {

  2102. 	verify(document.getElementById('edit').contentDocument.designMode == 'on');

  2103. 

  2104. 	idoc.execCommand('inserthtml', false, 'ABC');

  2105. 	verify(idoc.body.innerHTML == "<div>ABC<br></div>");

  2106. }

  2107. 

  2108. html

  2109. {

  2110. 	//! <script>

  2111. 	//! var win;

  2112. 	//! var idoc;

  2113. 	//! function do_onload()

  2114. 	//! {

  2115. 	//!   win = document.getElementById('edit').contentWindow;

  2116. 	//!   idoc = document.getElementById('edit').contentDocument;

  2117. 	//!   idoc.designMode = 'on';

  2118. 	//!   idoc.body.innerHTML = '<p>ABC</p>';

  2119. 	//!

  2120. 	//!   var r = idoc.createRange();

  2121. 	//!   r.setStart(idoc.getElementsByTagName('p')[0].firstChild, 3 );

  2122. 	//!   r.setEnd(idoc.getElementsByTagName('p')[0].firstChild, 3 );

  2123. 	//!   win.getSelection().removeAllRanges();

  2124. 	//!   win.getSelection().addRange(r);

  2125. 	//!

  2126. 	//! }

  2127. 	//! </script>

  2128. 	//! <body onload="do_onload()">

  2129. 	//! <iframe id="edit" width="40" height="40"></iframe>

  2130. 	//! </body>

  2131. }

  2132. 

  2133. 

  2134. test("Caret position set from DOM on text element") language ecmascript;

  2135. {

  2136. 	verify(document.getElementById('edit').contentDocument.designMode == 'on');

  2137. 

  2138. 	idoc.execCommand('inserthtml', false, 'DEF');

  2139. 	verify(idoc.body.innerHTML == "<p>ABCDEF</p>");

  2140. }

  2141. 

  2142. html

  2143. {

  2144. 	//! <script>

  2145. 	//! var win;

  2146. 	//! var idoc;

  2147. 	//! function do_onload()

  2148. 	//! {

  2149. 	//!   win = document.getElementById('edit').contentWindow;

  2150. 	//!   idoc = document.getElementById('edit').contentDocument;

  2151. 	//!   idoc.designMode = 'on';

  2152. 	//!   idoc.body.innerHTML = '<table><tbody><tr></tr></tbody></table>';

  2153. 	//!

  2154. 	//!   var r = idoc.createRange();

  2155. 	//!   r.setStart(idoc.getElementsByTagName('tr')[0], 0 );

  2156. 	//!   r.setEnd(idoc.getElementsByTagName('tr')[0], 0 );

  2157. 	//!   win.getSelection().removeAllRanges();

  2158. 	//!   win.getSelection().addRange(r);

  2159. 	//!

  2160. 	//! }

  2161. 	//! </script>

  2162. 	//! <body onload="do_onload()">

  2163. 	//! <iframe id="edit" width="40" height="40"></iframe>

  2164. 	//! </body>

  2165. }

  2166. 

  2167. 

  2168. test("Caret position set from DOM on non text element in no text container") language ecmascript;

  2169. {

  2170. 	verify(document.getElementById('edit').contentDocument.designMode == 'on');

  2171. 

  2172. 	idoc.execCommand('inserthtml', false, 'ABC');

  2173. 	verify(idoc.body.innerHTML == "<table><tbody><tr>ABC<br></tr></tbody></table>");

  2174. }