GuiDocumentClipboard

#include "GuiDocumentClipboard.h"

#include "GuiParserManager.h"

namespace

{

namespace

presentation

{

using

namespace

collections

;

using

namespace

parsing

xml

;

using

namespace

stream

;

namespace

document_clipboard_visitors

{

class

TraverseDocumentVisitor

public

Object

public

DocumentRun

IVisitor

{

public

TraverseDocumentVisitor

() { }

virtual

void

VisitContainer

(

DocumentContainerRun

run

) {

FOREACH(Ptr<DocumentRun>, childRun, run->runs)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

DocumentRun

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

run

runs

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

DocumentRun

childRun

;

__foreach_iterator__

(

childRun

);)

{

childRun

(

this

); } }

void

Visit

(

DocumentTextRun

run

)

override

{ }

void

Visit

(

DocumentStylePropertiesRun

run

)

override

{

VisitContainer

(

run

); }

void

Visit

(

DocumentStyleApplicationRun

run

)

override

{

VisitContainer

(

run

); }

void

Visit

(

DocumentHyperlinkRun

run

)

override

{

VisitContainer

(

run

); }

void

Visit

(

DocumentImageRun

run

)

override

{ }

void

Visit

(

DocumentEmbeddedObjectRun

run

)

override

{ }

void

Visit

(

DocumentParagraphRun

run

)

override

{

VisitContainer

(

run

); } };

class

ModifyDocumentForClipboardVisitor

public

TraverseDocumentVisitor

{

public

ModifyDocumentForClipboardVisitor

() { }

void

VisitContainer

(

DocumentContainerRun

run

)

override

{

for

(

vint

run

runs

Count

() -

;

--) {

auto

childRun

run

runs

[

];

(

childRun

Cast

DocumentEmbeddedObjectRun

>()) {

run

runs

RemoveAt

(

); } }

TraverseDocumentVisitor

VisitContainer

(

run

); } };

class

CollectImageRunsVisitor

public

TraverseDocumentVisitor

{

public

List

Ptr

DocumentImageRun

imageRuns

;

CollectImageRunsVisitor

() { }

void

Visit

(

DocumentImageRun

run

)

override

{

run

source

L"res://Image_"

itow

(

imageRuns

Count

());

imageRuns

Add

(

run

); } }; }

using

namespace

document_clipboard_visitors

;

void

ModifyDocumentForClipboard

(

Ptr

DocumentModel

model

) {

ModifyDocumentForClipboardVisitor

visitor

;

FOREACH(Ptr<DocumentParagraphRun>, paragraph, model->paragraphs)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

DocumentParagraphRun

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

model

paragraphs

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

DocumentParagraphRun

paragraph

;

__foreach_iterator__

(

paragraph

);)

{

paragraph

visitor

); } }

Ptr

DocumentModel

LoadDocumentFromClipboardStream

(

stream

IStream

clipboardStream

) {

auto

tempResource

MakePtr

GuiResource

>();

auto

tempResourceItem

MakePtr

GuiResourceItem

>();

tempResource

AddItem

(

L"Document"

tempResourceItem

);

auto

tempResolver

MakePtr

GuiResourcePathResolver

tempResource

L""

);

internal

ContextFreeReader

reader

(

clipboardStream

); {

WString

title

;

vint32_t

version

;

reader

title

version

;

(

title

L"WCF_Document"

version

) {

return

nullptr

; } }

WString

xmlText

;

reader

xmlText

;

List

GuiResourceError

errors

;

auto

parser

GetParserManager

()->

GetParser

XmlDocument

L"XML"

);

auto

xml

parser

->Parse({},

xmlText

errors

);

(

errors

Count

() >

)

return

nullptr

; {

vint32_t

count

;

reader

count

;

for

(

vint

;

count

;

++) {

MemoryStream

memoryStream

;

reader

(

IStream

memoryStream

;

(

auto

image

GetCurrentController

()->

ImageService

()->

CreateImageFromStream

(

memoryStream

)) {

auto

imageItem

MakePtr

GuiResourceItem

>();

imageItem

SetContent

(

L"Image"

MakePtr

GuiImageData

image

));

tempResource

AddItem

(

L"Image_"

itow

(

imageItem

); } } }

auto

document

DocumentModel

LoadFromXml

(

tempResourceItem

xml

tempResolver

errors

);

return

document

; }

void

SaveDocumentToClipboardStream

(

Ptr

DocumentModel

model

stream

IStream

clipboardStream

) {

CollectImageRunsVisitor

visitor

;

FOREACH(Ptr<DocumentParagraphRun>, paragraph, model->paragraphs)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

DocumentParagraphRun

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

model

paragraphs

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

DocumentParagraphRun

paragraph

;

__foreach_iterator__

(

paragraph

);)

{

paragraph

visitor

); }

internal

ContextFreeWriter

writer

(

clipboardStream

); {

WString

title

L"WCF_Document"

;

vint32_t

version

;

writer

title

version

; } {

auto

xmlText

GenerateToStream

([&](

StreamWriter

streamWriter

) {

auto

xml

model

SaveToXml

();

XmlPrint

(

xml

streamWriter

); });

writer

xmlText

; } {

vint32_t

count

= (

vint32_t

)

visitor

imageRuns

Count

();

writer

count

;

FOREACH(Ptr<DocumentImageRun>, imageRun, visitor.imageRuns)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

DocumentImageRun

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

visitor

imageRuns

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

DocumentImageRun

imageRun

;

__foreach_iterator__

(

imageRun

);)

{

MemoryStream

memoryStream

;

(

imageRun

image

) {

auto

format

imageRun

image

GetFormat

();

(

format

INativeImage

Gif

) {

format

INativeImage

Png

; }

imageRun

image

SaveToStream

(

memoryStream

format

); }

writer

(

stream

IStream

memoryStream

; } } } } }