mshtml: Moved getting HTTP header to separated function.
[wine] / dlls / mshtml / editor.c
1 /*
2  * Copyright 2006-2007 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <stdarg.h>
20 #include <stdio.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "ole2.h"
28 #include "mshtmcid.h"
29
30 #include "wine/debug.h"
31 #include "wine/unicode.h"
32
33 #include "mshtml_private.h"
34 #include "resource.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37
38 #define NSCMD_ALIGN        "cmd_align"
39 #define NSCMD_BEGINLINE    "cmd_beginLine"
40 #define NSCMD_BOLD         "cmd_bold"
41 #define NSCMD_CHARNEXT     "cmd_charNext"
42 #define NSCMD_CHARPREVIOUS "cmd_charPrevious"
43 #define NSCMD_COPY         "cmd_copy"
44 #define NSCMD_CUT          "cmd_cut"
45 #define NSCMD_DELETECHARFORWARD   "cmd_deleteCharForward"
46 #define NSCMD_DELETEWORDFORWARD   "cmd_deleteWordForward"
47 #define NSCMD_ENDLINE      "cmd_endLine"
48 #define NSCMD_FONTCOLOR    "cmd_fontColor"
49 #define NSCMD_FONTFACE     "cmd_fontFace"
50 #define NSCMD_INDENT       "cmd_indent"
51 #define NSCMD_INSERTHR     "cmd_insertHR"
52 #define NSCMD_INSERTLINKNOUI    "cmd_insertLinkNoUI"
53 #define NSCMD_ITALIC       "cmd_italic"
54 #define NSCMD_LINENEXT     "cmd_lineNext"
55 #define NSCMD_LINEPREVIOUS "cmd_linePrevious"
56 #define NSCMD_MOVEBOTTOM   "cmd_moveBottom"
57 #define NSCMD_MOVEPAGEDOWN "cmd_movePageDown"
58 #define NSCMD_MOVEPAGEUP   "cmd_movePageUp"
59 #define NSCMD_MOVETOP      "cmd_moveTop"
60 #define NSCMD_OL           "cmd_ol"
61 #define NSCMD_OUTDENT      "cmd_outdent"
62 #define NSCMD_PASTE        "cmd_paste"
63 #define NSCMD_SELECTALL           "cmd_selectAll"
64 #define NSCMD_SELECTBEGINLINE     "cmd_selectBeginLine"
65 #define NSCMD_SELECTBOTTOM        "cmd_selectBottom"
66 #define NSCMD_SELECTCHARNEXT      "cmd_selectCharNext"
67 #define NSCMD_SELECTCHARPREVIOUS  "cmd_selectCharPrevious"
68 #define NSCMD_SELECTENDLINE       "cmd_selectEndLine"
69 #define NSCMD_SELECTLINENEXT      "cmd_selectLineNext"
70 #define NSCMD_SELECTLINEPREVIOUS  "cmd_selectLinePrevious"
71 #define NSCMD_SELECTPAGEDOWN      "cmd_selectPageDown"
72 #define NSCMD_SELECTPAGEUP        "cmd_selectPageUp"
73 #define NSCMD_SELECTTOP           "cmd_selectTop"
74 #define NSCMD_SELECTWORDNEXT      "cmd_selectWordNext"
75 #define NSCMD_SELECTWORDPREVIOUS  "cmd_selectWordPrevious"
76 #define NSCMD_UL           "cmd_ul"
77 #define NSCMD_UNDERLINE    "cmd_underline"
78 #define NSCMD_WORDNEXT     "cmd_wordNext"
79 #define NSCMD_WORDPREVIOUS "cmd_wordPrevious"
80
81 #define NSSTATE_ATTRIBUTE "state_attribute"
82 #define NSSTATE_ALL       "state_all"
83
84 #define NSALIGN_CENTER "center"
85 #define NSALIGN_LEFT   "left"
86 #define NSALIGN_RIGHT  "right"
87
88 #define DOM_VK_LEFT     VK_LEFT
89 #define DOM_VK_UP       VK_UP
90 #define DOM_VK_RIGHT    VK_RIGHT
91 #define DOM_VK_DOWN     VK_DOWN
92 #define DOM_VK_DELETE   VK_DELETE
93 #define DOM_VK_HOME     VK_HOME
94 #define DOM_VK_END      VK_END
95
96 static const WCHAR fontW[] = {'f','o','n','t',0};
97 static const WCHAR sizeW[] = {'s','i','z','e',0};
98
99 void set_dirty(HTMLDocument *This, VARIANT_BOOL dirty)
100 {
101     nsresult nsres;
102
103     if(This->doc_obj->usermode != EDITMODE || !This->doc_obj->nscontainer || !This->doc_obj->nscontainer->editor)
104         return;
105
106     if(dirty) {
107         nsres = nsIEditor_IncrementModificationCount(This->doc_obj->nscontainer->editor, 1);
108         if(NS_FAILED(nsres))
109             ERR("IncrementModificationCount failed: %08x\n", nsres);
110     }else {
111         nsres = nsIEditor_ResetModificationCount(This->doc_obj->nscontainer->editor);
112         if(NS_FAILED(nsres))
113             ERR("ResetModificationCount failed: %08x\n", nsres);
114     }
115 }
116
117 static void do_ns_editor_command(NSContainer *This, const char *cmd)
118 {
119     nsresult nsres;
120
121     if(!This->editor_controller)
122         return;
123
124     nsres = nsIController_DoCommand(This->editor_controller, cmd);
125     if(NS_FAILED(nsres))
126         ERR("DoCommand(%s) failed: %08x\n", debugstr_a(cmd), nsres);
127 }
128
129 static nsresult get_ns_command_state(NSContainer *This, const char *cmd, nsICommandParams *nsparam)
130 {
131     nsICommandManager *cmdmgr;
132     nsresult nsres;
133
134     nsres = get_nsinterface((nsISupports*)This->webbrowser, &IID_nsICommandManager, (void**)&cmdmgr);
135     if(NS_FAILED(nsres)) {
136         ERR("Could not get nsICommandManager: %08x\n", nsres);
137         return nsres;
138     }
139
140     nsres = nsICommandManager_GetCommandState(cmdmgr, cmd, This->doc->basedoc.window->nswindow, nsparam);
141     if(NS_FAILED(nsres))
142         ERR("GetCommandState(%s) failed: %08x\n", debugstr_a(cmd), nsres);
143
144     nsICommandManager_Release(cmdmgr);
145     return nsres;
146 }
147
148 static DWORD query_ns_edit_status(HTMLDocument *This, const char *nscmd)
149 {
150     nsICommandParams *nsparam;
151     PRBool b = FALSE;
152
153     if(This->doc_obj->usermode != EDITMODE || This->window->readystate < READYSTATE_INTERACTIVE)
154         return OLECMDF_SUPPORTED;
155
156     if(This->doc_obj->nscontainer && nscmd) {
157         nsparam = create_nscommand_params();
158         get_ns_command_state(This->doc_obj->nscontainer, nscmd, nsparam);
159
160         nsICommandParams_GetBooleanValue(nsparam, NSSTATE_ALL, &b);
161
162         nsICommandParams_Release(nsparam);
163     }
164
165     return OLECMDF_SUPPORTED | OLECMDF_ENABLED | (b ? OLECMDF_LATCHED : 0);
166 }
167
168 static void set_ns_align(HTMLDocument *This, const char *align_str)
169 {
170     nsICommandParams *nsparam;
171
172     if(!This->doc_obj->nscontainer)
173         return;
174
175     nsparam = create_nscommand_params();
176     nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, align_str);
177
178     do_ns_command(This, NSCMD_ALIGN, nsparam);
179
180     nsICommandParams_Release(nsparam);
181 }
182
183 static DWORD query_align_status(HTMLDocument *This, const char *align_str)
184 {
185     nsICommandParams *nsparam;
186     char *align = NULL;
187
188     if(This->doc_obj->usermode != EDITMODE || This->window->readystate < READYSTATE_INTERACTIVE)
189         return OLECMDF_SUPPORTED;
190
191     if(This->doc_obj->nscontainer) {
192         nsparam = create_nscommand_params();
193         get_ns_command_state(This->doc_obj->nscontainer, NSCMD_ALIGN, nsparam);
194
195         nsICommandParams_GetCStringValue(nsparam, NSSTATE_ATTRIBUTE, &align);
196
197         nsICommandParams_Release(nsparam);
198     }
199
200     return OLECMDF_SUPPORTED | OLECMDF_ENABLED
201         | (align && !strcmp(align_str, align) ? OLECMDF_LATCHED : 0);
202 }
203
204
205 static nsISelection *get_ns_selection(HTMLDocument *This)
206 {
207     nsISelection *nsselection = NULL;
208     nsresult nsres;
209
210     nsres = nsIDOMWindow_GetSelection(This->window->nswindow, &nsselection);
211     if(NS_FAILED(nsres))
212         ERR("GetSelection failed %08x\n", nsres);
213
214     return nsselection;
215
216 }
217
218 static void remove_child_attr(nsIDOMElement *elem, LPCWSTR tag, nsAString *attr_str)
219 {
220     PRBool has_children;
221     PRUint32 child_cnt, i;
222     nsIDOMNode *child_node;
223     nsIDOMNodeList *node_list;
224     PRUint16 node_type;
225
226     nsIDOMElement_HasChildNodes(elem, &has_children);
227     if(!has_children)
228         return;
229
230     nsIDOMElement_GetChildNodes(elem, &node_list);
231     nsIDOMNodeList_GetLength(node_list, &child_cnt);
232
233     for(i=0; i<child_cnt; i++) {
234         nsIDOMNodeList_Item(node_list, i, &child_node);
235
236         nsIDOMNode_GetNodeType(child_node, &node_type);
237         if(node_type == ELEMENT_NODE) {
238             nsIDOMElement *child_elem;
239             nsAString tag_str;
240             const PRUnichar *ctag;
241
242             nsIDOMNode_QueryInterface(child_node, &IID_nsIDOMElement, (void**)&child_elem);
243
244             nsAString_Init(&tag_str, NULL);
245             nsIDOMElement_GetTagName(child_elem, &tag_str);
246             nsAString_GetData(&tag_str, &ctag);
247
248             if(!strcmpiW(ctag, tag))
249                 /* FIXME: remove node if there are no more attributes */
250                 nsIDOMElement_RemoveAttribute(child_elem, attr_str);
251
252             nsAString_Finish(&tag_str);
253
254             remove_child_attr(child_elem, tag, attr_str);
255
256             nsIDOMNode_Release(child_elem);
257         }
258
259         nsIDOMNode_Release(child_node);
260     }
261
262     nsIDOMNodeList_Release(node_list);
263 }
264
265 static void get_font_size(HTMLDocument *This, WCHAR *ret)
266 {
267     nsISelection *nsselection = get_ns_selection(This);
268     nsIDOMElement *elem = NULL;
269     nsIDOMNode *node = NULL, *tmp_node;
270     nsAString tag_str;
271     LPCWSTR tag;
272     PRUint16 node_type;
273     nsresult nsres;
274
275     *ret = 0;
276
277     if(!nsselection)
278         return;
279
280     nsISelection_GetFocusNode(nsselection, &node);
281     nsISelection_Release(nsselection);
282
283     while(node) {
284         nsres = nsIDOMNode_GetNodeType(node, &node_type);
285         if(NS_FAILED(nsres) || node_type == DOCUMENT_NODE)
286             break;
287
288         if(node_type == ELEMENT_NODE) {
289             nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
290
291             nsAString_Init(&tag_str, NULL);
292             nsIDOMElement_GetTagName(elem, &tag_str);
293             nsAString_GetData(&tag_str, &tag);
294
295             if(!strcmpiW(tag, fontW)) {
296                 nsAString size_str, val_str;
297                 LPCWSTR val;
298
299                 TRACE("found font tag %p\n", elem);
300
301                 nsAString_InitDepend(&size_str, sizeW);
302                 nsAString_Init(&val_str, NULL);
303
304                 nsIDOMElement_GetAttribute(elem, &size_str, &val_str);
305                 nsAString_GetData(&val_str, &val);
306
307                 if(*val) {
308                     TRACE("found size %s\n", debugstr_w(val));
309                     strcpyW(ret, val);
310                 }
311
312                 nsAString_Finish(&size_str);
313                 nsAString_Finish(&val_str);
314             }
315
316             nsAString_Finish(&tag_str);
317
318             nsIDOMElement_Release(elem);
319         }
320
321         if(*ret)
322             break;
323
324         tmp_node = node;
325         nsIDOMNode_GetParentNode(node, &node);
326         nsIDOMNode_Release(tmp_node);
327     }
328
329     if(node)
330         nsIDOMNode_Release(node);
331 }
332
333 static void set_font_size(HTMLDocument *This, LPCWSTR size)
334 {
335     nsISelection *nsselection;
336     PRBool collapsed;
337     nsIDOMHTMLElement *elem;
338     nsIDOMRange *range;
339     PRInt32 range_cnt = 0;
340     nsAString size_str;
341     nsAString val_str;
342
343     if(!This->doc_node->nsdoc) {
344         WARN("NULL nsdoc\n");
345         return;
346     }
347
348     nsselection = get_ns_selection(This);
349     if(!nsselection)
350         return;
351
352     nsISelection_GetRangeCount(nsselection, &range_cnt);
353     if(range_cnt != 1) {
354         FIXME("range_cnt %d not supprted\n", range_cnt);
355         if(!range_cnt) {
356             nsISelection_Release(nsselection);
357             return;
358         }
359     }
360
361     create_nselem(This->doc_node, fontW, &elem);
362
363     nsAString_InitDepend(&size_str, sizeW);
364     nsAString_InitDepend(&val_str, size);
365
366     nsIDOMElement_SetAttribute(elem, &size_str, &val_str);
367     nsAString_Finish(&val_str);
368
369     nsISelection_GetRangeAt(nsselection, 0, &range);
370     nsISelection_GetIsCollapsed(nsselection, &collapsed);
371     nsISelection_RemoveAllRanges(nsselection);
372
373     nsIDOMRange_SurroundContents(range, (nsIDOMNode*)elem);
374
375     if(collapsed) {
376         nsISelection_Collapse(nsselection, (nsIDOMNode*)elem, 0);
377     }else {
378         /* Remove all size attributes from the range */
379         remove_child_attr((nsIDOMElement*)elem, fontW, &size_str);
380         nsISelection_SelectAllChildren(nsselection, (nsIDOMNode*)elem);
381     }
382
383     nsISelection_Release(nsselection);
384     nsIDOMRange_Release(range);
385     nsIDOMElement_Release(elem);
386
387     nsAString_Finish(&size_str);
388
389     set_dirty(This, VARIANT_TRUE);
390 }
391
392 static void handle_arrow_key(HTMLDocument *This, nsIDOMKeyEvent *event, const char * const cmds[4])
393 {
394     int i=0;
395     PRBool b;
396
397     nsIDOMKeyEvent_GetCtrlKey(event, &b);
398     if(b)
399         i |= 1;
400
401     nsIDOMKeyEvent_GetShiftKey(event, &b);
402     if(b)
403         i |= 2;
404
405     if(cmds[i])
406         do_ns_editor_command(This->doc_obj->nscontainer, cmds[i]);
407
408     nsIDOMKeyEvent_PreventDefault(event);
409 }
410
411 void handle_edit_event(HTMLDocument *This, nsIDOMEvent *event)
412 {
413     nsIDOMKeyEvent *key_event;
414     PRUint32 code;
415
416     nsIDOMEvent_QueryInterface(event, &IID_nsIDOMKeyEvent, (void**)&key_event);
417
418     nsIDOMKeyEvent_GetKeyCode(key_event, &code);
419
420     switch(code) {
421     case DOM_VK_LEFT: {
422         static const char * const cmds[] = {
423             NSCMD_CHARPREVIOUS,
424             NSCMD_WORDPREVIOUS,
425             NSCMD_SELECTCHARPREVIOUS,
426             NSCMD_SELECTWORDPREVIOUS
427         };
428
429         TRACE("left\n");
430         handle_arrow_key(This, key_event, cmds);
431         break;
432     }
433     case DOM_VK_RIGHT: {
434         static const char * const cmds[] = {
435             NSCMD_CHARNEXT,
436             NSCMD_WORDNEXT,
437             NSCMD_SELECTCHARNEXT,
438             NSCMD_SELECTWORDNEXT
439         };
440
441         TRACE("right\n");
442         handle_arrow_key(This, key_event, cmds);
443         break;
444     }
445     case DOM_VK_UP: {
446         static const char * const cmds[] = {
447             NSCMD_LINEPREVIOUS,
448             NSCMD_MOVEPAGEUP,
449             NSCMD_SELECTLINEPREVIOUS,
450             NSCMD_SELECTPAGEUP
451         };
452
453         TRACE("up\n");
454         handle_arrow_key(This, key_event, cmds);
455         break;
456     }
457     case DOM_VK_DOWN: {
458         static const char * const cmds[] = {
459             NSCMD_LINENEXT,
460             NSCMD_MOVEPAGEDOWN,
461             NSCMD_SELECTLINENEXT,
462             NSCMD_SELECTPAGEDOWN
463         };
464
465         TRACE("down\n");
466         handle_arrow_key(This, key_event, cmds);
467         break;
468     }
469     case DOM_VK_DELETE: {
470         static const char * const cmds[] = {
471             NSCMD_DELETECHARFORWARD,
472             NSCMD_DELETEWORDFORWARD,
473             NULL, NULL
474         };
475
476         TRACE("delete\n");
477         handle_arrow_key(This, key_event, cmds);
478         break;
479     }
480     case DOM_VK_HOME: {
481         static const char * const cmds[] = {
482             NSCMD_BEGINLINE,
483             NSCMD_MOVETOP,
484             NSCMD_SELECTBEGINLINE,
485             NSCMD_SELECTTOP
486         };
487
488         TRACE("home\n");
489         handle_arrow_key(This, key_event, cmds);
490         break;
491     }
492     case DOM_VK_END: {
493         static const char * const cmds[] = {
494             NSCMD_ENDLINE,
495             NSCMD_MOVEBOTTOM,
496             NSCMD_SELECTENDLINE,
497             NSCMD_SELECTBOTTOM
498         };
499
500         TRACE("end\n");
501         handle_arrow_key(This, key_event, cmds);
502         break;
503     }
504     }
505
506     nsIDOMKeyEvent_Release(key_event);
507 }
508
509 void handle_edit_load(HTMLDocument *This)
510 {
511     get_editor_controller(This->doc_obj->nscontainer);
512 }
513
514 static void set_ns_fontname(HTMLDocument *This, const char *fontname)
515 {
516     nsICommandParams *nsparam = create_nscommand_params();
517
518     nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, fontname);
519     do_ns_command(This, NSCMD_FONTFACE, nsparam);
520     nsICommandParams_Release(nsparam);
521 }
522
523 static HRESULT exec_delete(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
524 {
525     TRACE("(%p)->(%p %p)\n", This, in, out);
526
527     if(This->doc_obj->nscontainer)
528         do_ns_editor_command(This->doc_obj->nscontainer, NSCMD_DELETECHARFORWARD);
529
530     update_doc(This, UPDATE_UI);
531     return S_OK;
532 }
533
534 static HRESULT exec_fontname(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
535 {
536     TRACE("(%p)->(%p %p)\n", This, in, out);
537
538     if(!This->doc_obj->nscontainer) {
539         update_doc(This, UPDATE_UI);
540         return E_FAIL;
541     }
542
543     if(in) {
544         char *stra;
545
546         if(V_VT(in) != VT_BSTR) {
547             FIXME("Unsupported vt=%d\n", V_VT(out));
548             return E_INVALIDARG;
549         }
550
551         TRACE("%s\n", debugstr_w(V_BSTR(in)));
552
553         stra = heap_strdupWtoA(V_BSTR(in));
554         set_ns_fontname(This, stra);
555         heap_free(stra);
556
557         update_doc(This, UPDATE_UI);
558     }
559
560     if(out) {
561         nsICommandParams *nsparam;
562         LPWSTR strw;
563         char *stra;
564         DWORD len;
565         nsresult nsres;
566
567         V_VT(out) = VT_BSTR;
568         V_BSTR(out) = NULL;
569
570         nsparam = create_nscommand_params();
571
572         nsres = get_ns_command_state(This->doc_obj->nscontainer, NSCMD_FONTFACE, nsparam);
573         if(NS_FAILED(nsres))
574             return S_OK;
575
576         nsICommandParams_GetCStringValue(nsparam, NSSTATE_ATTRIBUTE, &stra);
577         nsICommandParams_Release(nsparam);
578
579         len = MultiByteToWideChar(CP_ACP, 0, stra, -1, NULL, 0);
580         strw = heap_alloc(len*sizeof(WCHAR));
581         MultiByteToWideChar(CP_ACP, 0, stra, -1, strw, len);
582         nsfree(stra);
583
584         V_BSTR(out) = SysAllocString(strw);
585         heap_free(strw);
586     }
587
588     return S_OK;
589 }
590
591 static HRESULT exec_forecolor(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
592 {
593     TRACE("(%p)->(%p %p)\n", This, in, out);
594
595     if(in) {
596         if(V_VT(in) == VT_I4) {
597             nsICommandParams *nsparam = create_nscommand_params();
598             char color_str[10];
599
600             sprintf(color_str, "#%02x%02x%02x",
601                     V_I4(in)&0xff, (V_I4(in)>>8)&0xff, (V_I4(in)>>16)&0xff);
602
603             nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, color_str);
604             do_ns_command(This, NSCMD_FONTCOLOR, nsparam);
605
606             nsICommandParams_Release(nsparam);
607         }else {
608             FIXME("unsupported in vt=%d\n", V_VT(in));
609         }
610
611         update_doc(This, UPDATE_UI);
612     }
613
614     if(out) {
615         FIXME("unsupported out\n");
616         return E_NOTIMPL;
617     }
618
619     return S_OK;
620 }
621
622 static HRESULT exec_fontsize(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
623 {
624     TRACE("(%p)->(%p %p)\n", This, in, out);
625
626     if(out) {
627         WCHAR val[10] = {0};
628
629         get_font_size(This, val);
630         V_VT(out) = VT_I4;
631         V_I4(out) = strtolW(val, NULL, 10);
632     }
633
634     if(in) {
635         switch(V_VT(in)) {
636         case VT_I4: {
637             WCHAR size[10];
638             static const WCHAR format[] = {'%','d',0};
639             wsprintfW(size, format, V_I4(in));
640             set_font_size(This, size);
641             break;
642         }
643         case VT_BSTR:
644             set_font_size(This, V_BSTR(in));
645             break;
646         default:
647             FIXME("unsupported vt %d\n", V_VT(in));
648         }
649
650         update_doc(This, UPDATE_UI);
651     }
652
653     return S_OK;
654 }
655
656 static HRESULT exec_font(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
657 {
658
659     FIXME("(%p)->(%p %p)\n", This, in, out);
660     return E_NOTIMPL;
661 }
662
663 static HRESULT exec_selectall(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
664 {
665     TRACE("(%p)\n", This);
666
667     if(in || out)
668         FIXME("unsupported args\n");
669
670     if(This->doc_obj->nscontainer)
671         do_ns_command(This, NSCMD_SELECTALL, NULL);
672
673     update_doc(This, UPDATE_UI);
674     return S_OK;
675 }
676
677 static HRESULT exec_bold(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
678 {
679     TRACE("(%p)\n", This);
680
681     if(in || out)
682         FIXME("unsupported args\n");
683
684     if(This->doc_obj->nscontainer)
685         do_ns_command(This, NSCMD_BOLD, NULL);
686
687     update_doc(This, UPDATE_UI);
688     return S_OK;
689 }
690
691 static HRESULT exec_italic(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
692 {
693     TRACE("(%p)\n", This);
694
695     if(in || out)
696         FIXME("unsupported args\n");
697
698     if(This->doc_obj->nscontainer)
699         do_ns_command(This, NSCMD_ITALIC, NULL);
700
701     update_doc(This, UPDATE_UI);
702     return S_OK;
703 }
704
705 static HRESULT query_justify(HTMLDocument *This, OLECMD *cmd)
706 {
707     switch(cmd->cmdID) {
708     case IDM_JUSTIFYCENTER:
709         TRACE("(%p) IDM_JUSTIFYCENTER\n", This);
710         cmd->cmdf = query_align_status(This, NSALIGN_CENTER);
711         break;
712     case IDM_JUSTIFYLEFT:
713         TRACE("(%p) IDM_JUSTIFYLEFT\n", This);
714         /* FIXME: We should set OLECMDF_LATCHED only if it's set explicitly. */
715         if(This->doc_obj->usermode != EDITMODE || This->window->readystate < READYSTATE_INTERACTIVE)
716             cmd->cmdf = OLECMDF_SUPPORTED;
717         else
718             cmd->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
719         break;
720     case IDM_JUSTIFYRIGHT:
721         TRACE("(%p) IDM_JUSTIFYRIGHT\n", This);
722         cmd->cmdf = query_align_status(This, NSALIGN_RIGHT);
723         break;
724     }
725
726     return S_OK;
727 }
728
729 static HRESULT exec_justifycenter(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
730 {
731     TRACE("(%p)\n", This);
732
733     if(in || out)
734         FIXME("unsupported args\n");
735
736     set_ns_align(This, NSALIGN_CENTER);
737     update_doc(This, UPDATE_UI);
738     return S_OK;
739 }
740
741 static HRESULT exec_justifyleft(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
742 {
743     TRACE("(%p)\n", This);
744
745     if(in || out)
746         FIXME("unsupported args\n");
747
748     set_ns_align(This, NSALIGN_LEFT);
749     update_doc(This, UPDATE_UI);
750     return S_OK;
751 }
752
753 static HRESULT exec_justifyright(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
754 {
755     TRACE("(%p)\n", This);
756
757     if(in || out)
758         FIXME("unsupported args\n");
759
760     set_ns_align(This, NSALIGN_RIGHT);
761     update_doc(This, UPDATE_UI);
762     return S_OK;
763 }
764
765 static HRESULT exec_underline(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
766 {
767     TRACE("(%p)\n", This);
768
769     if(in || out)
770         FIXME("unsupported args\n");
771
772     do_ns_command(This, NSCMD_UNDERLINE, NULL);
773     update_doc(This, UPDATE_UI);
774     return S_OK;
775 }
776
777 static HRESULT exec_horizontalline(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
778 {
779     TRACE("(%p)\n", This);
780
781     if(in || out)
782         FIXME("unsupported args\n");
783
784     do_ns_command(This, NSCMD_INSERTHR, NULL);
785     update_doc(This, UPDATE_UI);
786     return S_OK;
787 }
788
789 static HRESULT exec_orderlist(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
790 {
791     TRACE("(%p)\n", This);
792
793     if(in || out)
794         FIXME("unsupported args\n");
795
796     do_ns_command(This, NSCMD_OL, NULL);
797     update_doc(This, UPDATE_UI);
798     return S_OK;
799 }
800
801 static HRESULT exec_unorderlist(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
802 {
803     TRACE("(%p)\n", This);
804
805     if(in || out)
806         FIXME("unsupported args\n");
807
808     do_ns_command(This, NSCMD_UL, NULL);
809     update_doc(This, UPDATE_UI);
810     return S_OK;
811 }
812
813 static HRESULT exec_indent(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
814 {
815     TRACE("(%p)\n", This);
816
817     if(in || out)
818         FIXME("unsupported args\n");
819
820     do_ns_command(This, NSCMD_INDENT, NULL);
821     update_doc(This, UPDATE_UI);
822     return S_OK;
823 }
824
825 static HRESULT exec_outdent(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
826 {
827     TRACE("(%p)\n", This);
828
829     if(in || out)
830         FIXME("unsupported args\n");
831
832     do_ns_command(This, NSCMD_OUTDENT, NULL);
833     update_doc(This, UPDATE_UI);
834     return S_OK;
835 }
836
837 static HRESULT exec_composesettings(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
838 {
839     WCHAR *ptr;
840
841     if(out || !in || V_VT(in) != VT_BSTR) {
842         WARN("invalid arg\n");
843         return E_INVALIDARG;
844     }
845
846     TRACE("(%p)->(%x %s)\n", This, cmdexecopt, debugstr_w(V_BSTR(in)));
847
848     update_doc(This, UPDATE_UI);
849
850     ptr = V_BSTR(in);
851     if(*ptr == '1')
852         exec_bold(This, cmdexecopt, NULL, NULL);
853     ptr = strchrW(ptr, ',');
854     if(!ptr)
855         return S_OK;
856
857     if(*++ptr == '1')
858         exec_italic(This, cmdexecopt, NULL, NULL);
859     ptr = strchrW(ptr, ',');
860     if(!ptr)
861         return S_OK;
862
863     if(*++ptr == '1')
864         exec_underline(This, cmdexecopt, NULL, NULL);
865     ptr = strchrW(ptr, ',');
866     if(!ptr)
867         return S_OK;
868
869     if(isdigitW(*++ptr)) {
870         VARIANT v;
871
872         V_VT(&v) = VT_I4;
873         V_I4(&v) = *ptr-'0';
874
875         exec_fontsize(This, cmdexecopt, &v, NULL);
876     }
877     ptr = strchrW(ptr, ',');
878     if(!ptr)
879         return S_OK;
880
881     if(*++ptr != ',')
882         FIXME("set font color\n");
883     ptr = strchrW(ptr, ',');
884     if(!ptr)
885         return S_OK;
886
887     if(*++ptr != ',')
888         FIXME("set background color\n");
889     ptr = strchrW(ptr, ',');
890     if(!ptr)
891         return S_OK;
892
893     ptr++;
894     if(*ptr) {
895         VARIANT v;
896
897         V_VT(&v) = VT_BSTR;
898         V_BSTR(&v) = SysAllocString(ptr);
899
900         exec_fontname(This, cmdexecopt, &v, NULL);
901
902         SysFreeString(V_BSTR(&v));
903     }
904
905     return S_OK;
906 }
907
908 HRESULT editor_exec_copy(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
909 {
910     update_doc(This, UPDATE_UI);
911
912     if(!This->doc_obj->nscontainer)
913         return E_FAIL;
914
915     do_ns_editor_command(This->doc_obj->nscontainer, NSCMD_COPY);
916     return S_OK;
917 }
918
919 HRESULT editor_exec_cut(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
920 {
921     update_doc(This, UPDATE_UI);
922
923     if(!This->doc_obj->nscontainer)
924         return E_FAIL;
925
926     do_ns_editor_command(This->doc_obj->nscontainer, NSCMD_CUT);
927     return S_OK;
928 }
929
930 HRESULT editor_exec_paste(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
931 {
932     update_doc(This, UPDATE_UI);
933
934     if(!This->doc_obj->nscontainer)
935         return E_FAIL;
936
937     do_ns_editor_command(This->doc_obj->nscontainer, NSCMD_PASTE);
938     return S_OK;
939 }
940
941 static HRESULT exec_setdirty(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
942 {
943     TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
944
945     if(!in)
946         return S_OK;
947
948     if(V_VT(in) == VT_BOOL)
949         set_dirty(This, V_BOOL(in));
950     else
951         FIXME("unsupported vt=%d\n", V_VT(in));
952
953     return S_OK;
954 }
955
956 static HRESULT query_edit_status(HTMLDocument *This, OLECMD *cmd)
957 {
958     switch(cmd->cmdID) {
959     case IDM_DELETE:
960         TRACE("CGID_MSHTML: IDM_DELETE\n");
961         cmd->cmdf = query_ns_edit_status(This, NULL);
962         break;
963     case IDM_FONTNAME:
964         TRACE("CGID_MSHTML: IDM_FONTNAME\n");
965         cmd->cmdf = query_ns_edit_status(This, NULL);
966         break;
967     case IDM_FONTSIZE:
968         TRACE("CGID_MSHTML: IDM_FONTSIZE\n");
969         cmd->cmdf = query_ns_edit_status(This, NULL);
970         break;
971     case IDM_BOLD:
972         TRACE("CGID_MSHTML: IDM_BOLD\n");
973         cmd->cmdf = query_ns_edit_status(This, NSCMD_BOLD);
974         break;
975     case IDM_FORECOLOR:
976         TRACE("CGID_MSHTML: IDM_FORECOLOR\n");
977         cmd->cmdf = query_ns_edit_status(This, NULL);
978         break;
979     case IDM_ITALIC:
980         TRACE("CGID_MSHTML: IDM_ITALIC\n");
981         cmd->cmdf = query_ns_edit_status(This, NSCMD_ITALIC);
982         break;
983     case IDM_UNDERLINE:
984         TRACE("CGID_MSHTML: IDM_UNDERLINE\n");
985         cmd->cmdf = query_ns_edit_status(This, NSCMD_UNDERLINE);
986         break;
987     case IDM_HORIZONTALLINE:
988         TRACE("CGID_MSHTML: IDM_HORIZONTALLINE\n");
989         cmd->cmdf = query_ns_edit_status(This, NULL);
990         break;
991     case IDM_ORDERLIST:
992         TRACE("CGID_MSHTML: IDM_ORDERLIST\n");
993         cmd->cmdf = query_ns_edit_status(This, NSCMD_OL);
994         break;
995     case IDM_UNORDERLIST:
996         TRACE("CGID_MSHTML: IDM_HORIZONTALLINE\n");
997         cmd->cmdf = query_ns_edit_status(This, NSCMD_UL);
998         break;
999     case IDM_INDENT:
1000         TRACE("CGID_MSHTML: IDM_INDENT\n");
1001         cmd->cmdf = query_ns_edit_status(This, NULL);
1002         break;
1003     case IDM_OUTDENT:
1004         TRACE("CGID_MSHTML: IDM_OUTDENT\n");
1005         cmd->cmdf = query_ns_edit_status(This, NULL);
1006         break;
1007     case IDM_HYPERLINK:
1008         TRACE("CGID_MSHTML: IDM_HYPERLINK\n");
1009         cmd->cmdf = query_ns_edit_status(This, NULL);
1010         break;
1011     }
1012
1013     return S_OK;
1014 }
1015
1016 static INT_PTR CALLBACK hyperlink_dlgproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1017 {
1018     static const WCHAR wszOther[] = {'(','o','t','h','e','r',')',0};
1019
1020     switch (msg)
1021     {
1022         case WM_INITDIALOG:
1023         {
1024             static const WCHAR wszFile[] = {'f','i','l','e',':',0};
1025             static const WCHAR wszFtp[] = {'f','t','p',':',0};
1026             static const WCHAR wszHttp[] = {'h','t','t','p',':',0};
1027             static const WCHAR wszHttps[] = {'h','t','t','p','s',':',0};
1028             static const WCHAR wszMailto[] = {'m','a','i','l','t','o',':',0};
1029             static const WCHAR wszNews[] = {'n','e','w','s',':',0};
1030             INT def_idx;
1031             HWND hwndCB = GetDlgItem(hwnd, IDC_TYPE);
1032             HWND hwndURL = GetDlgItem(hwnd, IDC_URL);
1033             INT len;
1034
1035             SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
1036
1037             SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszOther);
1038             SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszFile);
1039             SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszFtp);
1040             def_idx = SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszHttp);
1041             SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszHttps);
1042             SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszMailto);
1043             SendMessageW(hwndCB, CB_INSERTSTRING, -1, (LPARAM)wszNews);
1044             SendMessageW(hwndCB, CB_SETCURSEL, def_idx, 0);
1045
1046             /* force the updating of the URL edit box */
1047             SendMessageW(hwnd, WM_COMMAND, MAKEWPARAM(IDC_TYPE, CBN_SELCHANGE), (LPARAM)hwndCB);
1048
1049             SetFocus(hwndURL);
1050             len = SendMessageW(hwndURL, WM_GETTEXTLENGTH, 0, 0);
1051             SendMessageW(hwndURL, EM_SETSEL, 0, len);
1052
1053             return FALSE;
1054         }
1055         case WM_COMMAND:
1056             switch (wparam)
1057             {
1058                 case MAKEWPARAM(IDCANCEL, BN_CLICKED):
1059                     EndDialog(hwnd, wparam);
1060                     return TRUE;
1061                 case MAKEWPARAM(IDOK, BN_CLICKED):
1062                 {
1063                     BSTR *url = (BSTR *)GetWindowLongPtrW(hwnd, DWLP_USER);
1064                     HWND hwndURL = GetDlgItem(hwnd, IDC_URL);
1065                     INT len = GetWindowTextLengthW(hwndURL);
1066                     *url = SysAllocStringLen(NULL, len + 1);
1067                     GetWindowTextW(hwndURL, *url, len + 1);
1068                     EndDialog(hwnd, wparam);
1069                     return TRUE;
1070                 }
1071                 case MAKEWPARAM(IDC_TYPE, CBN_SELCHANGE):
1072                 {
1073                     HWND hwndURL = GetDlgItem(hwnd, IDC_URL);
1074                     INT item;
1075                     INT len;
1076                     LPWSTR type;
1077                     LPWSTR url;
1078                     LPWSTR p;
1079                     static const WCHAR wszSlashSlash[] = {'/','/'};
1080
1081                     /* get string of currently selected hyperlink type */
1082                     item = SendMessageW((HWND)lparam, CB_GETCURSEL, 0, 0);
1083                     len = SendMessageW((HWND)lparam, CB_GETLBTEXTLEN, item, 0);
1084                     type = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1085                     SendMessageW((HWND)lparam, CB_GETLBTEXT, item, (LPARAM)type);
1086
1087                     if (!strcmpW(type, wszOther))
1088                         *type = '\0';
1089
1090                     /* get current URL */
1091                     len = GetWindowTextLengthW(hwndURL);
1092                     url = HeapAlloc(GetProcessHeap(), 0, (len + strlenW(type) + 3) * sizeof(WCHAR));
1093                     GetWindowTextW(hwndURL, url, len + 1);
1094
1095                     /* strip off old protocol */
1096                     p = strchrW(url, ':');
1097                     if (p && p[1] == '/' && p[2] == '/')
1098                         p += 3;
1099                     if (!p) p = url;
1100                     memmove(url + (*type != '\0' ? strlenW(type) + 2 : 0), p, (len + 1 - (p - url)) * sizeof(WCHAR));
1101
1102                     /* add new protocol */
1103                     if (*type != '\0')
1104                     {
1105                         memcpy(url, type, strlenW(type) * sizeof(WCHAR));
1106                         memcpy(url + strlenW(type), wszSlashSlash, sizeof(wszSlashSlash));
1107                     }
1108
1109                     SetWindowTextW(hwndURL, url);
1110
1111                     HeapFree(GetProcessHeap(), 0, url);
1112                     HeapFree(GetProcessHeap(), 0, type);
1113                     return TRUE;
1114                 }
1115             }
1116             return FALSE;
1117         case WM_CLOSE:
1118             EndDialog(hwnd, IDCANCEL);
1119             return TRUE;
1120         default:
1121             return FALSE;
1122     }
1123 }
1124
1125 static HRESULT exec_hyperlink(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
1126 {
1127     nsAString href_str, ns_url;
1128     nsIHTMLEditor *html_editor;
1129     nsIDOMHTMLElement *anchor_elem;
1130     PRBool insert_link_at_caret;
1131     nsISelection *nsselection;
1132     BSTR url = NULL;
1133     INT ret;
1134     HRESULT hres = E_FAIL;
1135
1136     static const WCHAR aW[] = {'a',0};
1137     static const WCHAR hrefW[] = {'h','r','e','f',0};
1138
1139     TRACE("%p, 0x%x, %p, %p\n", This, cmdexecopt, in, out);
1140
1141     if (cmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER)
1142     {
1143         if (!in || V_VT(in) != VT_BSTR)
1144         {
1145             WARN("invalid arg\n");
1146             return E_INVALIDARG;
1147         }
1148         url = V_BSTR(in);
1149     }
1150     else
1151     {
1152         ret = DialogBoxParamW(hInst, MAKEINTRESOURCEW(IDD_HYPERLINK), NULL /* FIXME */, hyperlink_dlgproc, (LPARAM)&url);
1153         if (ret != IDOK)
1154             return OLECMDERR_E_CANCELED;
1155     }
1156
1157     if(!This->doc_node->nsdoc) {
1158         WARN("NULL nsdoc\n");
1159         return E_UNEXPECTED;
1160     }
1161
1162     nsselection = get_ns_selection(This);
1163     if (!nsselection)
1164         return E_FAIL;
1165
1166     /* create an element for the link */
1167     create_nselem(This->doc_node, aW, &anchor_elem);
1168
1169     nsAString_InitDepend(&href_str, hrefW);
1170     nsAString_InitDepend(&ns_url, url);
1171     nsIDOMElement_SetAttribute(anchor_elem, &href_str, &ns_url);
1172     nsAString_Finish(&href_str);
1173
1174     nsISelection_GetIsCollapsed(nsselection, &insert_link_at_caret);
1175
1176     /* create an element with text of URL */
1177     if (insert_link_at_caret) {
1178         nsIDOMNode *text_node, *unused_node;
1179
1180         nsIDOMDocument_CreateTextNode(This->doc_node->nsdoc, &ns_url, (nsIDOMText **)&text_node);
1181
1182         /* wrap the <a> tags around the text element */
1183         nsIDOMElement_AppendChild(anchor_elem, text_node, &unused_node);
1184         nsIDOMNode_Release(text_node);
1185         nsIDOMNode_Release(unused_node);
1186     }
1187
1188     nsAString_Finish(&ns_url);
1189
1190     nsIEditor_QueryInterface(This->doc_obj->nscontainer->editor, &IID_nsIHTMLEditor, (void **)&html_editor);
1191     if (html_editor) {
1192         nsresult nsres;
1193
1194         if (insert_link_at_caret) {
1195             /* add them to the document at the caret position */
1196             nsres = nsIHTMLEditor_InsertElementAtSelection(html_editor, (nsIDOMElement*)anchor_elem, FALSE);
1197             nsISelection_SelectAllChildren(nsselection, (nsIDOMNode*)anchor_elem);
1198         }else /* add them around the selection using the magic provided to us by nsIHTMLEditor */
1199             nsres = nsIHTMLEditor_InsertLinkAroundSelection(html_editor, (nsIDOMElement*)anchor_elem);
1200
1201         nsIHTMLEditor_Release(html_editor);
1202         hres = NS_SUCCEEDED(nsres) ? S_OK : E_FAIL;
1203     }
1204
1205     nsISelection_Release(nsselection);
1206     nsIDOMElement_Release(anchor_elem);
1207
1208     if (cmdexecopt != OLECMDEXECOPT_DONTPROMPTUSER)
1209         SysFreeString(url);
1210
1211     TRACE("-- 0x%08x\n", hres);
1212     return hres;
1213 }
1214
1215 static HRESULT query_selall_status(HTMLDocument *This, OLECMD *cmd)
1216 {
1217     TRACE("(%p)->(%p)\n", This, cmd);
1218
1219     cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
1220     return S_OK;
1221 }
1222
1223 const cmdtable_t editmode_cmds[] = {
1224     {IDM_DELETE,          query_edit_status,    exec_delete},
1225     {IDM_FONTNAME,        query_edit_status,    exec_fontname},
1226     {IDM_FONTSIZE,        query_edit_status,    exec_fontsize},
1227     {IDM_SELECTALL,       query_selall_status , exec_selectall},
1228     {IDM_FORECOLOR,       query_edit_status,    exec_forecolor},
1229     {IDM_BOLD,            query_edit_status,    exec_bold},
1230     {IDM_ITALIC,          query_edit_status,    exec_italic},
1231     {IDM_JUSTIFYCENTER,   query_justify,        exec_justifycenter},
1232     {IDM_JUSTIFYRIGHT,    query_justify,        exec_justifyright},
1233     {IDM_JUSTIFYLEFT,     query_justify,        exec_justifyleft},
1234     {IDM_FONT,            NULL,                 exec_font},
1235     {IDM_UNDERLINE,       query_edit_status,    exec_underline},
1236     {IDM_HORIZONTALLINE,  query_edit_status,    exec_horizontalline},
1237     {IDM_ORDERLIST,       query_edit_status,    exec_orderlist},
1238     {IDM_UNORDERLIST,     query_edit_status,    exec_unorderlist},
1239     {IDM_INDENT,          query_edit_status,    exec_indent},
1240     {IDM_OUTDENT,         query_edit_status,    exec_outdent},
1241     {IDM_COMPOSESETTINGS, NULL,                 exec_composesettings},
1242     {IDM_HYPERLINK,       query_edit_status,    exec_hyperlink},
1243     {IDM_SETDIRTY,        NULL,                 exec_setdirty},
1244     {0,NULL,NULL}
1245 };
1246
1247 void init_editor(HTMLDocument *This)
1248 {
1249     update_doc(This, UPDATE_UI);
1250
1251     set_ns_fontname(This, "Times New Roman");
1252 }
1253
1254 HRESULT editor_is_dirty(HTMLDocument *This)
1255 {
1256     PRBool modified;
1257
1258     if(!This->doc_obj->nscontainer || !This->doc_obj->nscontainer->editor)
1259         return S_FALSE;
1260
1261     nsIEditor_GetDocumentModified(This->doc_obj->nscontainer->editor, &modified);
1262
1263     return modified ? S_OK : S_FALSE;
1264 }