1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 | OSF.ClientMode={
|
12 | ReadWrite: 0,
|
13 | ReadOnly: 1
|
14 | }
|
15 | OSF.DDA.RichInitializationReason={
|
16 | 1: Microsoft.Office.WebExtension.InitializationReason.Inserted,
|
17 | 2: Microsoft.Office.WebExtension.InitializationReason.DocumentOpened
|
18 | };
|
19 | Microsoft.Office.WebExtension.FileType={
|
20 | Text: "text",
|
21 | Compressed: "compressed"
|
22 | };
|
23 | OSF.DDA.RichClientSettingsManager={
|
24 | read: function OSF_DDA_RichClientSettingsManager$Read(onCalling, onReceiving) {
|
25 | var keys=[];
|
26 | var values=[];
|
27 | if (onCalling) {
|
28 | onCalling();
|
29 | }
|
30 | window.external.GetContext().GetSettings().Read(keys, values);
|
31 | if (onReceiving) {
|
32 | onReceiving();
|
33 | }
|
34 | var serializedSettings={};
|
35 | for (var index=0; index < keys.length; index++) {
|
36 | serializedSettings[keys[index]]=values[index];
|
37 | }
|
38 | return serializedSettings;
|
39 | },
|
40 | write: function OSF_DDA_RichClientSettingsManager$Write(serializedSettings, overwriteIfStale, onCalling, onReceiving) {
|
41 | var keys=[];
|
42 | var values=[];
|
43 | for (var key in serializedSettings) {
|
44 | keys.push(key);
|
45 | values.push(serializedSettings[key]);
|
46 | }
|
47 | if (onCalling) {
|
48 | onCalling();
|
49 | }
|
50 | window.external.GetContext().GetSettings().Write(keys, values);
|
51 | if (onReceiving) {
|
52 | onReceiving();
|
53 | }
|
54 | }
|
55 | };
|
56 | OSF.DDA.DispIdHost.getRichClientDelegateMethods=function (actionId) {
|
57 | var delegateMethods={};
|
58 | delegateMethods[OSF.DDA.DispIdHost.Delegates.ExecuteAsync]=OSF.DDA.SafeArray.Delegate.executeAsync;
|
59 | delegateMethods[OSF.DDA.DispIdHost.Delegates.RegisterEventAsync]=OSF.DDA.SafeArray.Delegate.registerEventAsync;
|
60 | delegateMethods[OSF.DDA.DispIdHost.Delegates.UnregisterEventAsync]=OSF.DDA.SafeArray.Delegate.unregisterEventAsync;
|
61 | function getSettingsExecuteMethod(hostDelegateMethod) {
|
62 | return function (args) {
|
63 | var status, response;
|
64 | try {
|
65 | response=hostDelegateMethod(args.hostCallArgs, args.onCalling, args.onReceiving);
|
66 | status=OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess;
|
67 | } catch (ex) {
|
68 | status=OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError;
|
69 | response={ name : Strings.OfficeOM.L_InternalError, message : ex };
|
70 | }
|
71 | if (args.onComplete) {
|
72 | args.onComplete(status, response);
|
73 | }
|
74 | };
|
75 | }
|
76 | function readSerializedSettings(hostCallArgs, onCalling, onReceiving) {
|
77 | return OSF.DDA.RichClientSettingsManager.read(onCalling, onReceiving);
|
78 | }
|
79 | function writeSerializedSettings(hostCallArgs, onCalling, onReceiving) {
|
80 | return OSF.DDA.RichClientSettingsManager.write(
|
81 | hostCallArgs[OSF.DDA.SettingsManager.SerializedSettings],
|
82 | hostCallArgs[Microsoft.Office.WebExtension.Parameters.OverwriteIfStale],
|
83 | onCalling,
|
84 | onReceiving
|
85 | );
|
86 | }
|
87 | switch (actionId) {
|
88 | case OSF.DDA.AsyncMethodNames.RefreshAsync.id:
|
89 | delegateMethods[OSF.DDA.DispIdHost.Delegates.ExecuteAsync]=getSettingsExecuteMethod(readSerializedSettings);
|
90 | break;
|
91 | case OSF.DDA.AsyncMethodNames.SaveAsync.id:
|
92 | delegateMethods[OSF.DDA.DispIdHost.Delegates.ExecuteAsync]=getSettingsExecuteMethod(writeSerializedSettings);
|
93 | break;
|
94 | default:
|
95 | break;
|
96 | }
|
97 | return delegateMethods;
|
98 | }
|
99 | OSF.DDA.File=function OSF_DDA_File(handle, fileSize, sliceSize) {
|
100 | OSF.OUtil.defineEnumerableProperties(this, {
|
101 | "size": {
|
102 | value: fileSize
|
103 | },
|
104 | "sliceCount": {
|
105 | value: Math.ceil(fileSize / sliceSize)
|
106 | }
|
107 | });
|
108 | var privateState={};
|
109 | privateState[OSF.DDA.FileProperties.Handle]=handle;
|
110 | privateState[OSF.DDA.FileProperties.SliceSize]=sliceSize;
|
111 | var am=OSF.DDA.AsyncMethodNames;
|
112 | OSF.DDA.DispIdHost.addAsyncMethods(
|
113 | this, [
|
114 | am.GetDocumentCopyChunkAsync,
|
115 | am.ReleaseDocumentCopyAsync
|
116 | ],
|
117 | privateState
|
118 | );
|
119 | }
|
120 | OSF.DDA.FileSliceOffset="fileSliceoffset";
|
121 | OSF.DDA.CustomXmlParts=function OSF_DDA_CustomXmlParts() {
|
122 | this._eventDispatches=[];
|
123 | var am=OSF.DDA.AsyncMethodNames;
|
124 | OSF.DDA.DispIdHost.addAsyncMethods(this, [
|
125 | am.AddDataPartAsync,
|
126 | am.GetDataPartByIdAsync,
|
127 | am.GetDataPartsByNameSpaceAsync
|
128 | ]);
|
129 | };
|
130 | OSF.DDA.CustomXmlPart=function OSF_DDA_CustomXmlPart(customXmlParts, id, builtIn) {
|
131 | OSF.OUtil.defineEnumerableProperties(this, {
|
132 | "builtIn": {
|
133 | value: builtIn
|
134 | },
|
135 | "id": {
|
136 | value: id
|
137 | },
|
138 | "namespaceManager": {
|
139 | value: new OSF.DDA.CustomXmlPrefixMappings(id)
|
140 | }
|
141 | });
|
142 | var am=OSF.DDA.AsyncMethodNames;
|
143 | OSF.DDA.DispIdHost.addAsyncMethods(this, [
|
144 | am.DeleteDataPartAsync,
|
145 | am.GetPartNodesAsync,
|
146 | am.GetPartXmlAsync
|
147 | ]);
|
148 | var customXmlPartEventDispatches=customXmlParts._eventDispatches;
|
149 | var dispatch=customXmlPartEventDispatches[id];
|
150 | if (!dispatch) {
|
151 | var et=Microsoft.Office.WebExtension.EventType;
|
152 | dispatch=new OSF.EventDispatch([
|
153 | et.DataNodeDeleted,
|
154 | et.DataNodeInserted,
|
155 | et.DataNodeReplaced
|
156 | ]);
|
157 | customXmlPartEventDispatches[id]=dispatch;
|
158 | }
|
159 | OSF.DDA.DispIdHost.addEventSupport(this, dispatch);
|
160 | };
|
161 | OSF.DDA.CustomXmlPrefixMappings=function OSF_DDA_CustomXmlPrefixMappings(partId) {
|
162 | var am=OSF.DDA.AsyncMethodNames;
|
163 | OSF.DDA.DispIdHost.addAsyncMethods(
|
164 | this,
|
165 | [
|
166 | am.AddDataPartNamespaceAsync,
|
167 | am.GetDataPartNamespaceAsync,
|
168 | am.GetDataPartPrefixAsync
|
169 | ],
|
170 | partId
|
171 | );
|
172 | };
|
173 | OSF.DDA.CustomXmlNode=function OSF_DDA_CustomXmlNode(handle, nodeType, ns, baseName) {
|
174 | OSF.OUtil.defineEnumerableProperties(this, {
|
175 | "baseName": {
|
176 | value: baseName
|
177 | },
|
178 | "namespaceUri": {
|
179 | value: ns
|
180 | },
|
181 | "nodeType": {
|
182 | value: nodeType
|
183 | }
|
184 | });
|
185 | var am=OSF.DDA.AsyncMethodNames;
|
186 | OSF.DDA.DispIdHost.addAsyncMethods(
|
187 | this,
|
188 | [
|
189 | am.GetRelativeNodesAsync,
|
190 | am.GetNodeValueAsync,
|
191 | am.GetNodeXmlAsync,
|
192 | am.SetNodeValueAsync,
|
193 | am.SetNodeXmlAsync
|
194 | ],
|
195 | handle
|
196 | );
|
197 | };
|
198 | OSF.DDA.NodeInsertedEventArgs=function OSF_DDA_NodeInsertedEventArgs(newNode, inUndoRedo) {
|
199 | OSF.OUtil.defineEnumerableProperties(this, {
|
200 | "type": {
|
201 | value: Microsoft.Office.WebExtension.EventType.DataNodeInserted
|
202 | },
|
203 | "newNode": {
|
204 | value: newNode
|
205 | },
|
206 | "inUndoRedo": {
|
207 | value: inUndoRedo
|
208 | }
|
209 | });
|
210 | };
|
211 | OSF.DDA.NodeReplacedEventArgs=function OSF_DDA_NodeReplacedEventArgs(oldNode, newNode, inUndoRedo) {
|
212 | OSF.OUtil.defineEnumerableProperties(this, {
|
213 | "type": {
|
214 | value: Microsoft.Office.WebExtension.EventType.DataNodeReplaced
|
215 | },
|
216 | "oldNode": {
|
217 | value: oldNode
|
218 | },
|
219 | "newNode": {
|
220 | value: newNode
|
221 | },
|
222 | "inUndoRedo": {
|
223 | value: inUndoRedo
|
224 | }
|
225 | });
|
226 | };
|
227 | OSF.DDA.NodeDeletedEventArgs=function OSF_DDA_NodeDeletedEventArgs(oldNode, oldNextSibling, inUndoRedo) {
|
228 | OSF.OUtil.defineEnumerableProperties(this, {
|
229 | "type": {
|
230 | value: Microsoft.Office.WebExtension.EventType.DataNodeDeleted
|
231 | },
|
232 | "oldNode": {
|
233 | value: oldNode
|
234 | },
|
235 | "oldNextSibling": {
|
236 | value: oldNextSibling
|
237 | },
|
238 | "inUndoRedo": {
|
239 | value: inUndoRedo
|
240 | }
|
241 | });
|
242 | };
|
243 | OSF.OUtil.redefineList(Microsoft.Office.WebExtension.FileType, {
|
244 | Compressed: "compressed"
|
245 | });
|
246 | OSF.OUtil.redefineList(Microsoft.Office.WebExtension.CoercionType, {
|
247 | Text: "text"
|
248 | });
|
249 | OSF.OUtil.redefineList(Microsoft.Office.WebExtension.EventType, {
|
250 | DocumentSelectionChanged: "documentSelectionChanged"
|
251 | });
|
252 | OSF.OUtil.redefineList(Microsoft.Office.WebExtension.ValueFormat, {
|
253 | Unformatted: "unformatted"
|
254 | });
|
255 | OSF.OUtil.redefineList(Microsoft.Office.WebExtension.FilterType, {
|
256 | All: "all"
|
257 | });
|
258 | delete Microsoft.Office.WebExtension.BindingType;
|
259 | delete Microsoft.Office.WebExtension.select;
|
260 | OSF.OUtil.setNamespace("SafeArray", OSF.DDA);
|
261 | OSF.DDA.SafeArray.Response={
|
262 | Status: 0,
|
263 | Payload: 1
|
264 | };
|
265 | OSF.DDA.SafeArray.UniqueArguments={
|
266 | Offset: "offset",
|
267 | Run: "run",
|
268 | BindingSpecificData: "bindingSpecificData",
|
269 | MergedCellGuid: "{66e7831f-81b2-42e2-823c-89e872d541b3}"
|
270 | };
|
271 | OSF.OUtil.setNamespace("Delegate", OSF.DDA.SafeArray);
|
272 | OSF.DDA.SafeArray.Delegate.SpecialProcessor=function OSF_DDA_SafeArray_Delegate_SpecialProcessor() {
|
273 | function _2DVBArrayToJaggedArray(vbArr) {
|
274 | var ret;
|
275 | try {
|
276 | var rows=vbArr.ubound(1);
|
277 | var cols=vbArr.ubound(2);
|
278 | vbArr=vbArr.toArray();
|
279 | if (rows==1 && cols==1) {
|
280 | ret=[vbArr];
|
281 | } else {
|
282 | ret=[];
|
283 | for (var row=0; row < rows; row++) {
|
284 | var rowArr=[];
|
285 | for (var col=0; col < cols; col++) {
|
286 | var datum=vbArr[row * cols+col];
|
287 | if (datum !=OSF.DDA.SafeArray.UniqueArguments.MergedCellGuid) {
|
288 | rowArr.push(datum);
|
289 | }
|
290 | }
|
291 | if (rowArr.length > 0) {
|
292 | ret.push(rowArr);
|
293 | }
|
294 | }
|
295 | }
|
296 | } catch (ex) {
|
297 | }
|
298 | return ret;
|
299 | }
|
300 | var complexTypes=[
|
301 | OSF.DDA.PropertyDescriptors.FileProperties,
|
302 | OSF.DDA.PropertyDescriptors.FileSliceProperties,
|
303 | OSF.DDA.PropertyDescriptors.BindingProperties,
|
304 | OSF.DDA.SafeArray.UniqueArguments.BindingSpecificData,
|
305 | OSF.DDA.SafeArray.UniqueArguments.Offset,
|
306 | OSF.DDA.SafeArray.UniqueArguments.Run,
|
307 | OSF.DDA.PropertyDescriptors.Subset,
|
308 | OSF.DDA.PropertyDescriptors.DataPartProperties,
|
309 | OSF.DDA.PropertyDescriptors.DataNodeProperties,
|
310 | OSF.DDA.EventDescriptors.BindingSelectionChangedEvent,
|
311 | OSF.DDA.EventDescriptors.DataNodeInsertedEvent,
|
312 | OSF.DDA.EventDescriptors.DataNodeReplacedEvent,
|
313 | OSF.DDA.EventDescriptors.DataNodeDeletedEvent,
|
314 | OSF.DDA.DataNodeEventProperties.OldNode,
|
315 | OSF.DDA.DataNodeEventProperties.NewNode,
|
316 | OSF.DDA.DataNodeEventProperties.NextSiblingNode
|
317 | ];
|
318 | var dynamicTypes={};
|
319 | dynamicTypes[Microsoft.Office.WebExtension.Parameters.Data]=(function () {
|
320 | var tableRows=0;
|
321 | var tableHeaders=1;
|
322 | return {
|
323 | toHost: function OSF_DDA_SafeArray_Delegate_SpecialProcessor_Data$toHost(data) {
|
324 | if (typeof data !="string" && data[OSF.DDA.TableDataProperties.TableRows] !==undefined) {
|
325 | var tableData=[];
|
326 | tableData[tableRows]=data[OSF.DDA.TableDataProperties.TableRows];
|
327 | tableData[tableHeaders]=data[OSF.DDA.TableDataProperties.TableHeaders];
|
328 | data=tableData;
|
329 | }
|
330 | return data;
|
331 | },
|
332 | fromHost: function OSF_DDA_SafeArray_Delegate_SpecialProcessor_Data$fromHost(hostArgs) {
|
333 | var ret;
|
334 | if (hostArgs.toArray) {
|
335 | var dimensions=hostArgs.dimensions();
|
336 | if(dimensions===2) {
|
337 | ret=_2DVBArrayToJaggedArray(hostArgs);
|
338 | } else {
|
339 | var array=hostArgs.toArray();
|
340 | if(array.length===2 && ((array[0] !=null && array[0].toArray) || (array[1] !=null && array[1].toArray))) {
|
341 | ret={};
|
342 | ret[OSF.DDA.TableDataProperties.TableRows]=_2DVBArrayToJaggedArray(array[tableRows]);
|
343 | ret[OSF.DDA.TableDataProperties.TableHeaders]=_2DVBArrayToJaggedArray(array[tableHeaders]);
|
344 | } else {
|
345 | ret=array;
|
346 | }
|
347 | }
|
348 | } else {
|
349 | ret=hostArgs;
|
350 | }
|
351 | return ret;
|
352 | }
|
353 | }
|
354 | })();
|
355 | OSF.DDA.SafeArray.Delegate.SpecialProcessor.uber.constructor.call(this, complexTypes, dynamicTypes);
|
356 | this.pack=function OSF_DDA_SafeArray_Delegate_SpecialProcessor$pack(param, arg) {
|
357 | var value;
|
358 | if (this.isDynamicType(param)) {
|
359 | value=dynamicTypes[param].toHost(arg);
|
360 | } else {
|
361 | value=arg;
|
362 | }
|
363 | return value;
|
364 | };
|
365 | this.unpack=function OSF_DDA_SafeArray_Delegate_SpecialProcessor$unpack(param, arg) {
|
366 | var value;
|
367 | if (this.isComplexType(param) || OSF.DDA.ListType.isListType(param)) {
|
368 | try {
|
369 | value=arg.toArray();
|
370 | } catch (ex) {
|
371 | value=arg || {};
|
372 | }
|
373 | } else if (this.isDynamicType(param)) {
|
374 | value=dynamicTypes[param].fromHost(arg);
|
375 | } else {
|
376 | value=arg;
|
377 | }
|
378 | return value;
|
379 | };
|
380 | }
|
381 | OSF.OUtil.extend(OSF.DDA.SafeArray.Delegate.SpecialProcessor, OSF.DDA.SpecialProcessor);
|
382 | OSF.DDA.SafeArray.Delegate.ParameterMap=(function () {
|
383 | var parameterMap=new OSF.DDA.HostParameterMap(new OSF.DDA.SafeArray.Delegate.SpecialProcessor());
|
384 | var ns;
|
385 | var self=parameterMap.self;
|
386 | function createObject(properties) {
|
387 | var obj=null;
|
388 | if (properties) {
|
389 | obj={};
|
390 | var len=properties.length;
|
391 | for (var i=0; i < len; i++) {
|
392 | obj[properties[i].name]=properties[i].value;
|
393 | }
|
394 | }
|
395 | return obj;
|
396 | }
|
397 | function define(definition) {
|
398 | var args={};
|
399 | var toHost=createObject(definition.toHost);
|
400 | if (definition.invertible) {
|
401 | args.map=toHost;
|
402 | }
|
403 | else if (definition.canonical) {
|
404 | args.toHost=args.fromHost=toHost;
|
405 | }
|
406 | else {
|
407 | args.toHost=toHost;
|
408 | args.fromHost=createObject(definition.fromHost);
|
409 | }
|
410 | parameterMap.setMapping(definition.type, args);
|
411 | }
|
412 | ns=OSF.DDA.FileProperties;
|
413 | define({
|
414 | type: OSF.DDA.PropertyDescriptors.FileProperties,
|
415 | fromHost: [
|
416 | { name: ns.Handle, value: 0 },
|
417 | { name: ns.FileSize, value: 1 }
|
418 | ]
|
419 | });
|
420 | define({
|
421 | type: OSF.DDA.PropertyDescriptors.FileSliceProperties,
|
422 | fromHost: [
|
423 | { name: Microsoft.Office.WebExtension.Parameters.Data, value: 0 },
|
424 | { name: ns.SliceSize, value: 1}
|
425 | ]
|
426 | });
|
427 | ns=OSF.DDA.BindingProperties;
|
428 | define({
|
429 | type: OSF.DDA.PropertyDescriptors.BindingProperties,
|
430 | fromHost: [
|
431 | { name: ns.Id, value: 0 },
|
432 | { name: ns.Type, value: 1 },
|
433 | { name: OSF.DDA.SafeArray.UniqueArguments.BindingSpecificData, value: 2 }
|
434 | ]
|
435 | });
|
436 | define({
|
437 | type: OSF.DDA.SafeArray.UniqueArguments.BindingSpecificData,
|
438 | fromHost: [
|
439 | { name: ns.RowCount, value: 0 },
|
440 | { name: ns.ColumnCount, value: 1 },
|
441 | { name: ns.HasHeaders, value: 2 }
|
442 | ]
|
443 | });
|
444 | ns=OSF.DDA.SafeArray.UniqueArguments;
|
445 | define({
|
446 | type: OSF.DDA.PropertyDescriptors.Subset,
|
447 | toHost: [
|
448 | { name: ns.Offset, value: 0 },
|
449 | { name: ns.Run, value: 1 }
|
450 | ],
|
451 | canonical: true
|
452 | });
|
453 | ns=Microsoft.Office.WebExtension.Parameters;
|
454 | define({
|
455 | type: OSF.DDA.SafeArray.UniqueArguments.Offset,
|
456 | toHost: [
|
457 | { name: ns.StartRow, value: 0 },
|
458 | { name: ns.StartColumn, value: 1 }
|
459 | ],
|
460 | canonical: true
|
461 | });
|
462 | define({
|
463 | type: OSF.DDA.SafeArray.UniqueArguments.Run,
|
464 | toHost: [
|
465 | { name: ns.RowCount, value: 0 },
|
466 | { name: ns.ColumnCount, value: 1 }
|
467 | ],
|
468 | canonical: true
|
469 | });
|
470 | ns=OSF.DDA.DataPartProperties;
|
471 | define({
|
472 | type: OSF.DDA.PropertyDescriptors.DataPartProperties,
|
473 | fromHost: [
|
474 | { name: ns.Id, value: 0 },
|
475 | { name: ns.BuiltIn, value: 1 }
|
476 | ]
|
477 | });
|
478 | ns=OSF.DDA.DataNodeProperties;
|
479 | define({
|
480 | type: OSF.DDA.PropertyDescriptors.DataNodeProperties,
|
481 | fromHost: [
|
482 | { name: ns.Handle, value: 0 },
|
483 | { name: ns.BaseName, value: 1 },
|
484 | { name: ns.NamespaceUri, value: 2 },
|
485 | { name: ns.NodeType, value: 3 }
|
486 | ]
|
487 | });
|
488 | define({
|
489 | type: OSF.DDA.EventDescriptors.BindingSelectionChangedEvent,
|
490 | fromHost: [
|
491 | { name: OSF.DDA.PropertyDescriptors.BindingProperties, value: 0 },
|
492 | { name: OSF.DDA.PropertyDescriptors.Subset, value: 1 }
|
493 | ]
|
494 | });
|
495 | ns=OSF.DDA.DataNodeEventProperties;
|
496 | define({
|
497 | type: OSF.DDA.EventDescriptors.DataNodeInsertedEvent,
|
498 | fromHost: [
|
499 | { name: ns.InUndoRedo, value: 0 },
|
500 | { name: ns.NewNode, value: 1 }
|
501 | ]
|
502 | });
|
503 | define({
|
504 | type: OSF.DDA.EventDescriptors.DataNodeReplacedEvent,
|
505 | fromHost: [
|
506 | { name: ns.InUndoRedo, value: 0 },
|
507 | { name: ns.OldNode, value: 1 },
|
508 | { name: ns.NewNode, value: 2 }
|
509 | ]
|
510 | });
|
511 | define({
|
512 | type: OSF.DDA.EventDescriptors.DataNodeDeletedEvent,
|
513 | fromHost: [
|
514 | { name: ns.InUndoRedo, value: 0 },
|
515 | { name: ns.OldNode, value: 1 },
|
516 | { name: ns.NextSiblingNode, value: 2 }
|
517 | ]
|
518 | });
|
519 | define({
|
520 | type: ns.OldNode,
|
521 | fromHost: [
|
522 | { name: OSF.DDA.PropertyDescriptors.DataNodeProperties, value: self }
|
523 | ]
|
524 | });
|
525 | define({
|
526 | type: ns.NewNode,
|
527 | fromHost: [
|
528 | { name: OSF.DDA.PropertyDescriptors.DataNodeProperties, value: self }
|
529 | ]
|
530 | });
|
531 | define({
|
532 | type: ns.NextSiblingNode,
|
533 | fromHost: [
|
534 | { name: OSF.DDA.PropertyDescriptors.DataNodeProperties, value: self }
|
535 | ]
|
536 | });
|
537 | ns=Microsoft.Office.WebExtension.AsyncResultStatus;
|
538 | define({
|
539 | type: OSF.DDA.PropertyDescriptors.AsyncResultStatus,
|
540 | fromHost: [
|
541 | { name: ns.Succeeded, value: 0 },
|
542 | { name: ns.Failed, value: 1 }
|
543 | ]
|
544 | });
|
545 | ns=Microsoft.Office.WebExtension.CoercionType;
|
546 | define({
|
547 | type: Microsoft.Office.WebExtension.Parameters.CoercionType,
|
548 | toHost: [
|
549 | { name: ns.Text, value: 0 },
|
550 | { name: ns.Matrix, value: 1 },
|
551 | { name: ns.Table, v |
\ | No newline at end of file |