JucerDocument* JucerDocument::createForCppFile (Project* p, const File& file)
{
OpenDocumentManager& odm = IntrojucerApp::getApp().openDocumentManager;
if (SourceCodeDocument* cpp = dynamic_cast<SourceCodeDocument*> (odm.openFile (p, file)))
if (dynamic_cast<SourceCodeDocument*> (odm.openFile (p, file.withFileExtension (".h"))) != nullptr)
return createDocument (cpp);
return nullptr;
}
void DocumentWriter::begin(const KURL& urlReference, bool dispatch, Document* ownerDocument)
{
// We grab a local copy of the URL because it's easy for callers to supply
// a URL that will be deallocated during the execution of this function.
// For example, see <https://bugs.webkit.org/show_bug.cgi?id=66360>.
KURL url = urlReference;
// Create a new document before clearing the frame, because it may need to
// inherit an aliased security context.
RefPtr<Document> document = createDocument(url);
// If the new document is for a Plugin but we're supposed to be sandboxed from Plugins,
// then replace the document with one whose parser will ignore the incoming data (bug 39323)
if (document->isPluginDocument() && document->isSandboxed(SandboxPlugins))
document = SinkDocument::create(m_frame, url);
// FIXME: Do we need to consult the content security policy here about blocked plug-ins?
bool shouldReuseDefaultView = m_frame->loader()->stateMachine()->isDisplayingInitialEmptyDocument() && m_frame->document()->isSecureTransitionTo(url);
if (shouldReuseDefaultView)
document->takeDOMWindowFrom(m_frame->document());
else
document->createDOMWindow();
m_frame->loader()->clear(document.get(), !shouldReuseDefaultView, !shouldReuseDefaultView);
clear();
if (!shouldReuseDefaultView)
m_frame->script()->updatePlatformScriptObjects();
m_frame->loader()->setOutgoingReferrer(url);
m_frame->setDocument(document);
if (m_decoder)
document->setDecoder(m_decoder.get());
if (ownerDocument) {
document->setCookieURL(ownerDocument->cookieURL());
document->setSecurityOrigin(ownerDocument->securityOrigin());
}
m_frame->loader()->didBeginDocument(dispatch);
document->implicitOpen();
// We grab a reference to the parser so that we'll always send data to the
// original parser, even if the document acquires a new parser (e.g., via
// document.open).
m_parser = document->parser();
if (m_frame->view() && m_frame->loader()->client()->hasHTMLView())
m_frame->view()->setContentsSize(IntSize());
m_state = StartedWritingState;
}
TEST_F(ImageDocumentTest, ZoomingDoesNotChangeRelativeSize) {
createDocument(75, 75);
setPageZoom(0.5f);
document().windowSizeChanged();
EXPECT_EQ(50, imageWidth());
EXPECT_EQ(50, imageHeight());
setPageZoom(2.f);
document().windowSizeChanged();
EXPECT_EQ(50, imageWidth());
EXPECT_EQ(50, imageHeight());
}
Document* CreateValid06() {
Document* doc = createDocument();
DNAComponent *com = createDNAComponent(doc, "http://example.com/dc1");
// dc1 has two rdf:type nodes, which libSBOL ignores
setDNAComponentDisplayID(com, "DC1");
setDNAComponentName(com, "DnaComponent1");
setDNAComponentDescription(com, "A DnaComponent can optionally use a type from Sequence Ontology");
DNASequence *seq = createDNASequence(doc, "http://example.com/ds1");
setDNASequenceNucleotides(seq, "tccctatcagtgat");
setDNAComponentSequence(com, seq);
return doc;
}
void DocumentResource::checkNotify()
{
if (m_data) {
StringBuilder decodedText;
decodedText.append(m_decoder->decode(m_data->data(), m_data->size()));
decodedText.append(m_decoder->flush());
// We don't need to create a new frame because the new document belongs to the parent UseElement.
m_document = createDocument(response().url());
m_document->setContent(decodedText.toString());
}
Resource::checkNotify();
}
void EditorTabWidget::addDocument(KURL url)
{
int index;
if((index = documentIndex(url.path())) != -1) {
//file already opened, show it
this->setCurrentPage(index);
} else {
createDocument(url);
}
enableEditorActions();
emit sigNewDocument();
}
EditorFrame::EditorFrame(const wxString& title)
: wxFrame(nullptr, wxID_ANY, title)
, paneCtrl(nullptr)
, toolbarCtrl(nullptr)
, statusCtrl(nullptr)
, notebookCtrl(nullptr)
, eventManager(nullptr)
, pluginManager(nullptr)
, documentManager(nullptr)
, engine(nullptr)
, archive(nullptr)
, input(nullptr)
{
gs_EditorInstance = this;
CoreInitialize();
#ifdef EDITOR_OLD_UI
documentManager = AllocateThis(DocumentManager);
documentManager->onDocumentAdded.Connect(this, &EditorFrame::onDocumentAdded);
documentManager->onDocumentRemoved.Connect(this, &EditorFrame::onDocumentRemoved);
documentManager->onDocumentRenamed.Connect(this, &EditorFrame::onDocumentRenamed);
#endif
createPlugins();
#ifdef EDITOR_OLD_UI
createUI();
#endif
createEngine();
eventManager = AllocateThis(EventManager);
#ifdef ENABLE_PLUGIN_MONO
Plugin* monoPlugin = pluginManager->getPluginFromClass( ReflectionGetType(MonoPlugin) );
pluginManager->enablePlugin(monoPlugin);
#endif
#ifdef EDITOR_OLD_UI
enablePlugins();
createToolbar();
createLastUI();
#endif
Bind(wxEVT_IDLE, &EditorFrame::OnIdle, this);
Bind(wxEVT_CLOSE_WINDOW, &EditorFrame::OnClose, this);
auto projectPlugin = GetPlugin<ProjectPlugin>();
projectPlugin->createDocument();
}
void MainWindow::open(QString fileName = QString("")) {
QStringList fileNames;
if (fileName.isEmpty()) {
fileNames = QFileDialog::getOpenFileNames(this, "Select one or more files to open", (openFiles.size() > 0 && !getCurFileObj()->path.isEmpty()) ? getCurFileObj()->path : lastDir);
} else {
fileNames.push_front(fileName);
}
while (fileNames.count()) {
if (!fileNames.back().isEmpty()) {
bool alreadyOpen = false;
QList<QsciteEditor *> openTabs = openFiles.keys();
QList<QsciteEditor *>::iterator tab;
for (tab = openTabs.begin(); tab != openTabs.end(); ++tab) {
if (fileNames.front() == openFiles[*tab].fullName) {
alreadyOpen = true;
if (fileNames.count() == 1) {
changeTabs(*tab);
}
qDebug() << "file is already open";
}
}
if (alreadyOpen) {
fileNames.pop_front();
continue;
}
if ((!tabWidget->count()) || (!getCurFileObj()->baseName.isEmpty()) || getCurDoc()->isModified()) {
createDocument();
}
loadFile(fileNames.front());
setCurrentTabTitle();
addRecentFile(fileNames.front());
}
fileNames.pop_front();
}
if (!openFiles.empty()) {
getCurDoc()->setFocus();
lastDir = getCurFileObj()->path;
}
}
std::vector<Document> Documents::create(const QVector<FileContainer> &fileContainers)
{
checkIfDocumentsDoNotExist(fileContainers);
std::vector<Document> createdDocuments;
for (const FileContainer &fileContainer : fileContainers) {
if (fileContainer.hasUnsavedFileContent())
updateDocumentsWithChangedDependency(fileContainer.filePath());
createdDocuments.push_back(createDocument(fileContainer));
}
return createdDocuments;
}
void DocumentWriter::begin(const KURL& urlReference, bool dispatch, SecurityOrigin* origin)
{
// We need to take a reference to the security origin because |clear|
// might destroy the document that owns it.
RefPtr<SecurityOrigin> forcedSecurityOrigin = origin;
// We grab a local copy of the URL because it's easy for callers to supply
// a URL that will be deallocated during the execution of this function.
// For example, see <https://bugs.webkit.org/show_bug.cgi?id=66360>.
KURL url = urlReference;
// Create a new document before clearing the frame, because it may need to
// inherit an aliased security context.
RefPtr<Document> document = createDocument(url);
// If the new document is for a Plugin but we're supposed to be sandboxed from Plugins,
// then replace the document with one whose parser will ignore the incoming data (bug 39323)
if (document->isPluginDocument() && m_frame->loader()->isSandboxed(SandboxPlugins))
document = SinkDocument::create(m_frame, url);
// FIXME: Do we need to consult the content security policy here about blocked plug-ins?
bool resetScripting = !(m_frame->loader()->stateMachine()->isDisplayingInitialEmptyDocument() && m_frame->document()->securityOrigin()->isSecureTransitionTo(url));
m_frame->loader()->clear(resetScripting, resetScripting);
clear();
if (resetScripting)
m_frame->script()->updatePlatformScriptObjects();
m_frame->loader()->setOutgoingReferrer(url);
m_frame->setDocument(document);
if (m_decoder)
document->setDecoder(m_decoder.get());
if (forcedSecurityOrigin)
document->setSecurityOrigin(forcedSecurityOrigin.get());
m_frame->domWindow()->setURL(document->url());
m_frame->domWindow()->setSecurityOrigin(document->securityOrigin());
m_frame->loader()->didBeginDocument(dispatch);
document->implicitOpen();
if (m_frame->view() && m_frame->loader()->client()->hasHTMLView())
m_frame->view()->setContentsSize(IntSize());
}
void TestCreateSequenceAnnotation(CuTest* tc) {
Document* doc = createDocument();
char* uri;
SequenceAnnotation* ann;
int repeat;
for (repeat=0; repeat<NUM_FAST_TESTS; repeat++) {
uri = randomUniqueURI(doc);
ann = createSequenceAnnotation(doc, uri);
CuAssertIntEquals(tc, 1, getNumSequenceAnnotations(doc));
CuAssertStrEquals(tc, uri, getSequenceAnnotationURI(ann));
CuAssertIntEquals(tc, -1, getSequenceAnnotationStart(ann));
CuAssertIntEquals(tc, -1, getSequenceAnnotationEnd(ann));
CuAssertIntEquals(tc, 0, getNumPrecedes(ann));
deleteSequenceAnnotation(ann);
CuAssertIntEquals(tc, 0, getNumSequenceAnnotations(doc));
}
deleteDocument(doc);
}
void DocumentWriter::begin(const KURL& url, bool dispatch, SecurityOrigin* origin)
{
// We need to take a reference to the security origin because |clear|
// might destroy the document that owns it.
RefPtr<SecurityOrigin> forcedSecurityOrigin = origin;
// Create a new document before clearing the frame, because it may need to
// inherit an aliased security context.
RefPtr<Document> document = createDocument(url);
// If the new document is for a Plugin but we're supposed to be sandboxed from Plugins,
// then replace the document with one whose parser will ignore the incoming data (bug 39323)
if (document->isPluginDocument() && m_frame->loader()->isSandboxed(SandboxPlugins))
document = SinkDocument::create(m_frame, url);
// FIXME: Do we need to consult the content security policy here about blocked plug-ins?
bool resetScripting = !(m_frame->loader()->stateMachine()->isDisplayingInitialEmptyDocument() && m_frame->document()->securityOrigin()->isSecureTransitionTo(url));
m_frame->loader()->clear(resetScripting, resetScripting);
clear();
m_frame->loader()->setOutgoingReferrer(url);
m_frame->setDocument(document);
if (m_decoder)
document->setDecoder(m_decoder.get());
if (forcedSecurityOrigin)
document->setSecurityOrigin(forcedSecurityOrigin.get());
m_frame->domWindow()->setURL(document->url());
m_frame->domWindow()->setSecurityOrigin(document->securityOrigin());
m_frame->loader()->didBeginDocument(dispatch);
document->implicitOpen();
// We grab a reference to the parser so that we'll always send data to the
// original parser, even if the document acquires a new parser (e.g., via
// document.open).
m_parser = document->parser();
if (m_frame->view() && m_frame->loader()->client()->hasHTMLView())
m_frame->view()->setContentsSize(IntSize());
}
Document* CreateValid04() {
Document* doc = createDocument();
// components
DNAComponent *dc1 = createDNAComponent(doc, "http://example.com/dc1");
DNAComponent *dc2 = createDNAComponent(doc, "http://example.com/dc2");
setDNAComponentDisplayID(dc1, "DC1");
setDNAComponentDisplayID(dc2, "DC2");
setDNAComponentName(dc1, "DnaComponent1");
setDNAComponentName(dc2, "DnaComponent2");
setDNAComponentDescription(dc1, "DnaComponent with one sequence annotation");
setDNAComponentDescription(dc2, "Another DNA component");
// sequence
DNASequence *ds1 = createDNASequence(doc, "http://example.com/ds1");
setDNASequenceNucleotides(ds1, "tccctatcagtgat");
setDNAComponentSequence(dc1, ds1);
// annotation
SequenceAnnotation *sa1 = createSequenceAnnotation(doc, "http://example.com/sa1");
setSequenceAnnotationSubComponent(sa1, dc2);
addSequenceAnnotation(dc1, sa1);
return doc;
}
Document* CreateValid11() {
Document* doc = createDocument();
// collection
Collection *col = createCollection(doc, "http://example.com/collection1");
setCollectionDisplayID(col, "Coll1");
setCollectionName(col, "Collection1");
setCollectionDescription(col, "A collection may contain multiple components");
// components
DNAComponent *dc1 = createDNAComponent(doc, "http://example.com/dc1");
DNAComponent *dc2 = createDNAComponent(doc, "http://example.com/dc2");
setDNAComponentDisplayID(dc1, "DC1");
setDNAComponentDisplayID(dc2, "DC2");
setDNAComponentName(dc1, "DnaComponent1");
setDNAComponentName(dc2, "DnaComponent2");
addDNAComponentToCollection(col, dc1);
addDNAComponentToCollection(col, dc2);
// sequence
DNASequence *ds1 = createDNASequence(doc, "http://example.com/ds1");
setDNASequenceNucleotides(ds1, "tccctatcagtgat");
setDNAComponentSequence(dc1, ds1);
return doc;
}
void KoItemToolTip::showTip(QWidget *widget, const QPoint &pos, const QStyleOptionViewItem &option, const QModelIndex &index)
{
QTextDocument *doc = createDocument(index);
QPoint p = (isVisible() && index == d->index) ? d->pos : pos;
if (!isVisible() || index != d->index || doc->toHtml() != d->document->toHtml())
{
d->pos = p;
d->index = index;
delete d->document;
d->document = doc;
updatePosition(widget, p, option);
if (!isVisible())
show();
else
update();
d->timer.start(10000, this);
}
else
delete doc;
}
void DocumentWriter::begin(const KURL& url, bool dispatch, SecurityOrigin* origin)
{
// We need to take a reference to the security origin because |clear|
// might destroy the document that owns it.
RefPtr<SecurityOrigin> forcedSecurityOrigin = origin;
// Create a new document before clearing the frame, because it may need to
// inherit an aliased security context.
RefPtr<Document> document = createDocument();
// If the new document is for a Plugin but we're supposed to be sandboxed from Plugins,
// then replace the document with one whose tokenizer will ignore the incoming data (bug 39323)
if (document->isPluginDocument() && m_frame->loader()->isSandboxed(SandboxPlugins))
document = SinkDocument::create(m_frame);
bool resetScripting = !(m_frame->loader()->isDisplayingInitialEmptyDocument() && m_frame->document()->securityOrigin()->isSecureTransitionTo(url));
m_frame->loader()->clear(resetScripting, resetScripting);
if (resetScripting)
m_frame->script()->updatePlatformScriptObjects();
m_frame->loader()->setURL(url);
document->setURL(url);
m_frame->setDocument(document);
if (m_decoder)
document->setDecoder(m_decoder.get());
if (forcedSecurityOrigin)
document->setSecurityOrigin(forcedSecurityOrigin.get());
m_frame->domWindow()->setURL(document->url());
m_frame->domWindow()->setSecurityOrigin(document->securityOrigin());
m_frame->loader()->didBeginDocument(dispatch);
document->implicitOpen();
if (m_frame->view() && m_frame->loader()->client()->hasHTMLView())
m_frame->view()->setContentsSize(IntSize());
}
PassRefPtr<Document> DOMImplementation::createDocument(const String& type, Frame* frame, const KURL& url, bool inViewSourceMode)
{
return createDocument(type, DocumentInit(url, frame), inViewSourceMode);
}
// Documents
daeInt daeSTLDatabase::insertDocument(const char *name, daeElement* dom, daeDocument** document)
{
return createDocument( name, dom, document );
}
std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult &mtpData) {
using StringToTypeMap = QMap<QString, Result::Type>;
static StaticNeverFreedPointer<StringToTypeMap> stringToTypeMap{ ([]() -> StringToTypeMap* {
auto result = std_::make_unique<StringToTypeMap>();
result->insert(qsl("photo"), Result::Type::Photo);
result->insert(qsl("video"), Result::Type::Video);
result->insert(qsl("audio"), Result::Type::Audio);
result->insert(qsl("voice"), Result::Type::Audio);
result->insert(qsl("sticker"), Result::Type::Sticker);
result->insert(qsl("file"), Result::Type::File);
result->insert(qsl("gif"), Result::Type::Gif);
result->insert(qsl("article"), Result::Type::Article);
result->insert(qsl("contact"), Result::Type::Contact);
result->insert(qsl("venue"), Result::Type::Venue);
result->insert(qsl("geo"), Result::Type::Geo);
result->insert(qsl("game"), Result::Type::Game);
return result.release();
})() };
auto getInlineResultType = [](const MTPBotInlineResult &inlineResult) -> Type {
QString type;
switch (inlineResult.type()) {
case mtpc_botInlineResult: type = qs(inlineResult.c_botInlineResult().vtype); break;
case mtpc_botInlineMediaResult: type = qs(inlineResult.c_botInlineMediaResult().vtype); break;
}
return stringToTypeMap->value(type, Type::Unknown);
};
Type type = getInlineResultType(mtpData);
if (type == Type::Unknown) {
return std_::unique_ptr<Result>();
}
auto result = std_::make_unique<Result>(Creator{ queryId, type });
const MTPBotInlineMessage *message = nullptr;
switch (mtpData.type()) {
case mtpc_botInlineResult: {
const auto &r(mtpData.c_botInlineResult());
result->_id = qs(r.vid);
if (r.has_title()) result->_title = qs(r.vtitle);
if (r.has_description()) result->_description = qs(r.vdescription);
if (r.has_url()) result->_url = qs(r.vurl);
if (r.has_thumb_url()) result->_thumb_url = qs(r.vthumb_url);
if (r.has_content_type()) result->_content_type = qs(r.vcontent_type);
if (r.has_content_url()) result->_content_url = qs(r.vcontent_url);
if (r.has_w()) result->_width = r.vw.v;
if (r.has_h()) result->_height = r.vh.v;
if (r.has_duration()) result->_duration = r.vduration.v;
if (!result->_thumb_url.startsWith(qstr("http://"), Qt::CaseInsensitive) && !result->_thumb_url.startsWith(qstr("https://"), Qt::CaseInsensitive)) {
result->_thumb_url = QString();
}
message = &r.vsend_message;
} break;
case mtpc_botInlineMediaResult: {
const auto &r(mtpData.c_botInlineMediaResult());
result->_id = qs(r.vid);
if (r.has_title()) result->_title = qs(r.vtitle);
if (r.has_description()) result->_description = qs(r.vdescription);
if (r.has_photo()) {
result->_photo = App::feedPhoto(r.vphoto);
}
if (r.has_document()) {
result->_document = App::feedDocument(r.vdocument);
}
message = &r.vsend_message;
} break;
}
bool badAttachment = (result->_photo && !result->_photo->access) || (result->_document && !result->_document->isValid());
if (!message) {
return std_::unique_ptr<Result>();
}
// Ensure required media fields for layouts.
if (result->_type == Type::Photo) {
if (!result->_photo && result->_content_url.isEmpty()) {
return std_::unique_ptr<Result>();
}
result->createPhoto();
} else if (result->_type == Type::File || result->_type == Type::Gif || result->_type == Type::Sticker) {
if (!result->_document && result->_content_url.isEmpty()) {
return std_::unique_ptr<Result>();
}
result->createDocument();
}
switch (message->type()) {
case mtpc_botInlineMessageMediaAuto: {
auto &r = message->c_botInlineMessageMediaAuto();
if (result->_type == Type::Photo) {
result->createPhoto();
result->sendData.reset(new internal::SendPhoto(result->_photo, qs(r.vcaption)));
} else if (result->_type == Type::Game) {
result->createGame();
result->sendData.reset(new internal::SendGame(result->_game));
} else {
result->createDocument();
result->sendData.reset(new internal::SendFile(result->_document, qs(r.vcaption)));
}
if (r.has_reply_markup()) {
result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
}
} break;
case mtpc_botInlineMessageText: {
auto &r = message->c_botInlineMessageText();
EntitiesInText entities = r.has_entities() ? entitiesFromMTP(r.ventities.c_vector().v) : EntitiesInText();
result->sendData.reset(new internal::SendText(qs(r.vmessage), entities, r.is_no_webpage()));
if (result->_type == Type::Photo) {
result->createPhoto();
} else if (result->_type == Type::Audio || result->_type == Type::File || result->_type == Type::Video || result->_type == Type::Sticker || result->_type == Type::Gif) {
result->createDocument();
}
if (r.has_reply_markup()) {
result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
}
} break;
case mtpc_botInlineMessageMediaGeo: {
auto &r = message->c_botInlineMessageMediaGeo();
if (r.vgeo.type() == mtpc_geoPoint) {
result->sendData.reset(new internal::SendGeo(r.vgeo.c_geoPoint()));
} else {
badAttachment = true;
}
if (r.has_reply_markup()) {
result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
}
} break;
case mtpc_botInlineMessageMediaVenue: {
auto &r = message->c_botInlineMessageMediaVenue();
if (r.vgeo.type() == mtpc_geoPoint) {
result->sendData.reset(new internal::SendVenue(r.vgeo.c_geoPoint(), qs(r.vvenue_id), qs(r.vprovider), qs(r.vtitle), qs(r.vaddress)));
} else {
badAttachment = true;
}
if (r.has_reply_markup()) {
result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
}
} break;
case mtpc_botInlineMessageMediaContact: {
auto &r = message->c_botInlineMessageMediaContact();
result->sendData.reset(new internal::SendContact(qs(r.vfirst_name), qs(r.vlast_name), qs(r.vphone_number)));
if (r.has_reply_markup()) {
result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
}
} break;
default: {
badAttachment = true;
} break;
}
if (badAttachment || !result->sendData || !result->sendData->isValid()) {
return std_::unique_ptr<Result>();
}
if (result->_thumb->isNull() && !result->_thumb_url.isEmpty()) {
result->_thumb = ImagePtr(result->_thumb_url);
}
LocationCoords location;
if (result->getLocationCoords(&location)) {
int32 w = st::inlineThumbSize, h = st::inlineThumbSize;
int32 zoom = 13, scale = 1;
if (cScale() == dbisTwo || cRetina()) {
scale = 2;
w /= 2;
h /= 2;
}
QString coords = qsl("%1,%2").arg(location.lat).arg(location.lon);
QString url = qsl("https://maps.googleapis.com/maps/api/staticmap?center=") + coords + qsl("&zoom=%1&size=%2x%3&maptype=roadmap&scale=%4&markers=color:red|size:big|").arg(zoom).arg(w).arg(h).arg(scale) + coords + qsl("&sensor=false");
result->_locationThumb = ImagePtr(url);
}
return result;
}
go_bandit([](){
describe("GraphIO", []() {
describe("SVG", []() {
std::unique_ptr<Graph> graph;
int numberOfNodes = 42;
before_each([&](){
graph.reset(new Graph);
randomBiconnectedGraph(*graph, numberOfNodes, 3*numberOfNodes);
});
it("is well-formed", [&]() {
GraphAttributes attr(*graph);
pugi::xml_document doc;
createDocument(attr, doc);
pugi::xml_node svg = doc.child("svg");
AssertThat((bool) svg, IsTrue());
AssertThat(svg.attribute("viewBox").empty(), IsFalse());
AssertThat(static_cast<int>(svg.select_nodes("//rect").size()), Equals(graph->numberOfNodes()));
AssertThat(static_cast<int>(svg.select_nodes("//path").size()), Equals(graph->numberOfEdges()));
});
it("supports 3D", [&]() {
GraphAttributes attr(*graph,
GraphAttributes::nodeGraphics |
GraphAttributes::nodeStyle |
GraphAttributes::edgeGraphics |
GraphAttributes::threeD |
TEST_F(ImageDocumentTest, RestoreImageOnClick) {
createDocument(30, 40);
document().imageClicked(4, 4);
EXPECT_EQ(50, imageWidth());
EXPECT_EQ(50, imageHeight());
}
TEST_F(ImageDocumentTest, ImageLoad) {
createDocument(50, 50);
EXPECT_EQ(50, imageWidth());
EXPECT_EQ(50, imageHeight());
}
XalanDocument*
XercesParserLiaison::parseXMLStream(
const InputSourceType& reader,
const XalanDOMString& /* identifier */)
{
XalanAutoPtr<DOMParserType> theParser(CreateDOMParser());
if (m_errorHandler == 0)
{
theParser->setErrorHandler(this);
}
else
{
theParser->setErrorHandler(m_errorHandler);
}
theParser->parse(reader);
#if XERCES_VERSION_MAJOR >= 2
DOMDocument_Type* const theXercesDocument =
theParser->getDocument();
theXercesDocument->normalize();
#else
DOM_Document_Type theXercesDocument =
theParser->getDocument();
theXercesDocument.normalize();
#endif
#if XERCES_VERSION_MAJOR >= 2
XercesDocumentWrapper* theNewDocument = 0;
if (theXercesDocument != 0)
{
theNewDocument = doCreateDocument(theXercesDocument, m_threadSafe, m_buildWrapper, m_buildMaps, true);
theParser->adoptDocument();
#else
XercesDocumentBridge* theNewDocument = 0;
if (theXercesDocument.isNull() == false)
{
theNewDocument = doCreateDocument(theXercesDocument, m_threadSafe, m_buildBridge, true);
#endif
}
return theNewDocument;
}
void
XercesParserLiaison::destroyDocument(XalanDocument* theDocument)
{
const DocumentMapType::iterator i =
m_documentMap.find(theDocument);
if (i != m_documentMap.end())
{
const XalanAutoPtr<XalanDocument> theGuard(theDocument);
m_documentMap.erase(i);
}
}
int
XercesParserLiaison::getIndent() const
{
return m_indent;
}
void
XercesParserLiaison::setIndent(int i)
{
m_indent = i;
}
bool
XercesParserLiaison::getUseValidation() const
{
return m_useValidation;
}
void
XercesParserLiaison::setUseValidation(bool b)
{
m_useValidation = b;
}
const XalanDOMString
XercesParserLiaison::getParserDescription() const
{
return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("Xerces"));
}
DOMDocument_Type*
XercesParserLiaison::createDOMFactory()
{
DOMDocument_Type* const theXercesDocument =
DOMImplementationType::getImplementation()->createDocument();
createDocument(theXercesDocument, false, false);
return theXercesDocument;
}
void
XercesParserLiaison::destroyDocument(DOMDocument_Type* theDocument)
{
// Delete any live documents...
for(DocumentMapType::iterator i = m_documentMap.begin();
i != m_documentMap.end();
++i)
{
if ((*i).second.isDeprecated() == false &&
(*i).second.m_wrapper->getXercesDocument() == theDocument)
{
destroyDocument((XalanDocument*)(*i).first);
}
}
}
bool
XercesParserLiaison::getIncludeIgnorableWhitespace() const
{
return m_includeIgnorableWhitespace;
}
void
XercesParserLiaison::setIncludeIgnorableWhitespace(bool include)
{
m_includeIgnorableWhitespace = include;
}
ErrorHandlerType*
XercesParserLiaison::getErrorHandler() const
{
return m_errorHandler;
}
void
XercesParserLiaison::setErrorHandler(ErrorHandlerType* handler)
{
m_errorHandler = handler;
}
bool
XercesParserLiaison::getDoNamespaces() const
{
return m_doNamespaces;
}
void
XercesParserLiaison::setDoNamespaces(bool newState)
{
m_doNamespaces = newState;
}
bool
XercesParserLiaison::getExitOnFirstFatalError() const
{
return m_exitOnFirstFatalError;
}
void
XercesParserLiaison::setExitOnFirstFatalError(bool newState)
{
m_exitOnFirstFatalError = newState;
}
EntityResolverType*
XercesParserLiaison::getEntityResolver() const
{
return m_entityResolver;
}
void
XercesParserLiaison::setEntityResolver(EntityResolverType* resolver)
{
m_entityResolver = resolver;
}
const XalanDOMChar*
XercesParserLiaison::getExternalSchemaLocation() const
{
return m_externalSchemaLocation.length() == 0 ? 0 : m_externalSchemaLocation.c_str();
}
void
XercesParserLiaison::setExternalSchemaLocation(const XalanDOMChar* location)
{
if (location == 0)
{
m_externalSchemaLocation.clear();
}
else
{
m_externalSchemaLocation = location;
}
}
const XalanDOMChar*
XercesParserLiaison::getExternalNoNamespaceSchemaLocation() const
{
return m_externalNoNamespaceSchemaLocation.length() == 0 ? 0 : m_externalNoNamespaceSchemaLocation.c_str();
}
void
XercesParserLiaison::setExternalNoNamespaceSchemaLocation(const XalanDOMChar* location)
{
if (location == 0)
{
m_externalNoNamespaceSchemaLocation.clear();
}
else
{
m_externalNoNamespaceSchemaLocation= location;
}
}
#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
XalanDocument*
XercesParserLiaison::createDocument(
const DOM_Document_Type& theXercesDocument,
bool threadSafe,
bool buildBridge)
{
return doCreateDocument(theXercesDocument, threadSafe, buildBridge);
}
#endif
XalanDocument*
XercesParserLiaison::createDocument(
const DOMDocument_Type* theXercesDocument,
bool threadSafe,
bool buildWrapper,
bool buildMaps)
{
// As we did not create the underlying DOMDocument - ensure we don't
// delete it later.
return doCreateDocument(theXercesDocument, threadSafe, buildWrapper, buildMaps, false);
}
#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
XercesDocumentBridge*
XercesParserLiaison::mapDocument(const XalanDocument* theDocument) const
{
const DocumentMapType::const_iterator i =
m_documentMap.find(theDocument);
return i != m_documentMap.end() ? (*i).second.m_isDeprecated == true ? (*i).second.m_bridge : 0 : 0;
}
#endif
XercesDocumentWrapper*
XercesParserLiaison::mapDocumentToWrapper(const XalanDocument* theDocument) const
{
const DocumentMapType::const_iterator i =
m_documentMap.find(theDocument);
return i != m_documentMap.end() ? (*i).second.isDeprecated() == false ? (*i).second.m_wrapper : 0 : 0;
}
#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
DOM_Document_Type
XercesParserLiaison::mapXercesDocument(const XalanDocument* theDocument) const
{
const DocumentMapType::const_iterator i =
m_documentMap.find(theDocument);
return i != m_documentMap.end() ? (*i).second.isDeprecated() == true ? (*i).second.m_bridge->getXercesDocument() : DOM_Document_Type() : DOM_Document_Type();
}
#endif
const DOMDocument_Type*
XercesParserLiaison::mapToXercesDocument(const XalanDocument* theDocument) const
{
const DocumentMapType::const_iterator i =
m_documentMap.find(theDocument);
return i != m_documentMap.end() ? (*i).second.isDeprecated() == false ? (*i).second.m_wrapper->getXercesDocument() : 0 : 0;
}
void
XercesParserLiaison::fatalError(const SAXParseExceptionType& e)
{
XalanDOMString theMessage = XalanMessageLoader::getMessage(XalanMessages::FatalError);
formatErrorMessage(e, theMessage);
if (m_executionContext != 0)
{
// We call warning() because we don't want the execution
// context to potentially throw an exception.
m_executionContext->warn(theMessage);
}
else
{
XALAN_USING_STD(cerr)
XALAN_USING_STD(endl)
cerr << endl << theMessage << endl;
}
throw e;
}
KoFilter::ConversionStatus KoOdfExporter::convert(const QByteArray& from, const QByteArray& to)
{
// check for proper conversion
if (!acceptsSourceMimeType(from)) {
kWarning(30003) << "Invalid source mimetype" << from;
return KoFilter::NotImplemented;
}
if (!acceptsDestinationMimeType(to)) {
kWarning(30003) << "Invalid destination mimetype" << to;
return KoFilter::NotImplemented;
}
//create output files
KoStore *outputStore = KoStore::createStore(m_chain->outputFile(), KoStore::Write, to, KoStore::Zip);
if (!outputStore || outputStore->bad()) {
kWarning(30003) << "Unable to open output file!";
delete outputStore;
return KoFilter::FileNotFound;
}
outputStore->disallowNameExpansion();
kDebug(30003) << "created outputStore.";
KoOdfWriteStore oasisStore(outputStore);
kDebug(30003) << "created oasisStore.";
// KoGenStyles for writing styles while we're parsing
KoGenStyles mainStyles;
KoOdfWriters writers;
writers.mainStyles = &mainStyles;
// create a writer for meta.xml
QBuffer buf;
buf.open(QIODevice::WriteOnly);
KoXmlWriter metaWriter(&buf);
writers.meta = &metaWriter;
// create a writer for manifest.xml
QBuffer manifestBuf;
manifestBuf.open(QIODevice::WriteOnly);
KoXmlWriter manifestWriter(&manifestBuf);
writers.manifest = &manifestWriter;
//open contentWriter & bodyWriter *temp* writers
//so we can write picture files while we parse
QBuffer contentBuf;
KoXmlWriter contentWriter(&contentBuf);
writers.content = &contentWriter;
QBuffer bodyBuf;
KoXmlWriter bodyWriter(&bodyBuf);
writers.body = &bodyWriter;
// open main tags
bodyWriter.startElement("office:body");
bodyWriter.startElement(d->bodyContentElement.constData());
RETURN_IF_ERROR( createDocument(outputStore, &writers) )
//save the office:automatic-styles & and fonts in content.xml
mainStyles.saveOdfStyles(KoGenStyles::FontFaceDecls, &contentWriter);
mainStyles.saveOdfStyles(KoGenStyles::DocumentAutomaticStyles, &contentWriter);
//close tags in body
bodyWriter.endElement();//office:*
bodyWriter.endElement();//office:body
//now create real content/body writers & dump the information there
KoXmlWriter* realContentWriter = oasisStore.contentWriter();
if (!realContentWriter) {
kWarning(30003) << "Error creating the content writer.";
delete outputStore;
return KoFilter::CreationError;
}
realContentWriter->addCompleteElement(&contentBuf);
KoXmlWriter* realBodyWriter = oasisStore.bodyWriter();
if (!realBodyWriter) {
kWarning(30003) << "Error creating the body writer.";
delete outputStore;
return KoFilter::CreationError;
}
realBodyWriter->addCompleteElement(&bodyBuf);
//now close content & body writers
if (!oasisStore.closeContentWriter()) {
kWarning(30003) << "Error closing content.";
delete outputStore;
return KoFilter::CreationError;
}
kDebug(30003) << "closed content & body writers.";
//create the manifest file
KoXmlWriter* realManifestWriter = oasisStore.manifestWriter(to);
//create the styles.xml file
mainStyles.saveOdfStylesDotXml(outputStore, realManifestWriter);
realManifestWriter->addManifestEntry("content.xml", "text/xml");
realManifestWriter->addCompleteElement(&manifestBuf);
kDebug(30003) << "created manifest and styles.xml";
// create settings.xml, apparently it is used to note calligra that msoffice files should
// have different behavior with some things
if (!outputStore->open("settings.xml")) {
delete outputStore;
return KoFilter::CreationError;
}
KoStoreDevice settingsDev(outputStore);
KoXmlWriter* settings = KoOdfWriteStore::createOasisXmlWriter(&settingsDev, "office:document-settings");
settings->startElement("office:settings");
settings->startElement("config:config-item-set");
settings->addAttribute("config:name", "ooo:configuration-settings");
writeConfigurationSettings(settings);
settings->endElement(); // config:config-item-set
settings->endElement(); // office:settings
settings->endElement(); // office:document-settings
settings->endDocument();
delete settings;
realManifestWriter->addManifestEntry("settings.xml", "text/xml");
if (!outputStore->close()) {
delete outputStore;
return KoFilter::CreationError;
}
//create meta.xml
if (!outputStore->open("meta.xml")) {
delete outputStore;
return KoFilter::CreationError;
}
KoStoreDevice metaDev(outputStore);
KoXmlWriter* meta = KoOdfWriteStore::createOasisXmlWriter(&metaDev, "office:document-meta");
meta->startElement("office:meta");
meta->addCompleteElement(&buf);
meta->endElement(); //office:meta
meta->endElement(); //office:document-meta
meta->endDocument();
delete meta;
if (!outputStore->close()) {
delete outputStore;
return KoFilter::CreationError;
}
realManifestWriter->addManifestEntry("meta.xml", "text/xml");
oasisStore.closeManifestWriter();
delete outputStore;
return KoFilter::OK;
}
void MainWindow::newFile() {
createDocument();
getCurDoc()->setFocus();
}
menu->addAction( actNewDocument );
menu->addAction( actCopyDocument );
menu->addAction( actFollowDocument );
menu->addSeparator();
menu->addAction( actPrintDocument );
menu->addAction( actMailDocument );
menu->addAction( actOpenArchivedDocument );
}
connect( m_portalView, SIGNAL(openKatalog( const QString&)),
this, SLOT(slotOpenKatalog(const QString&)));
connect( m_portalView, SIGNAL(katalogToXML(const QString& )),
this, SLOT(slotKatalogToXML(const QString&)));
// document related connections
connect( m_portalView, SIGNAL( createDocument() ),
this, SLOT( slotNewDocument() ) );
connect( m_portalView, SIGNAL( copyDocument( const QString& ) ),
this, SLOT( slotCopyDocument( const QString& ) ) );
connect( m_portalView, SIGNAL( openDocument( const QString& ) ),
this, SLOT( slotOpenDocument( const QString& ) ) );
connect( m_portalView, SIGNAL( viewDocument( const QString& ) ),
this, SLOT( slotViewDocument( const QString& ) ) );
connect( m_portalView, SIGNAL( openArchivedDocument( const ArchDocDigest& ) ),
this, SLOT( slotOpenArchivedDoc( const ArchDocDigest& ) ) );
connect( m_portalView, SIGNAL( printDocument( const QString& ) ),
this, SLOT( slotPrintDocument() ) );
connect( m_portalView, SIGNAL( documentSelected( const QString& ) ),
this, SLOT( slotDocumentSelected( const QString& ) ) );
connect( m_portalView, SIGNAL( archivedDocSelected( const ArchDocDigest& ) ),
this, SLOT( slotArchivedDocSelected( const ArchDocDigest& ) ) );
IDocBasePtr FileEngine::createDocument(const QString sourcePath, const QByteArray &blob)
{
(void) sourcePath;
return createDocument(blob);
}
int main( int argc, const char** argv)
{
try
{
initRand();
g_errorBuffer = strus::createErrorBuffer_standard( 0, 1, NULL/*debug trace interface*/);
if (!g_errorBuffer)
{
std::cerr << "construction of error buffer failed" << std::endl;
return -1;
}
else if (argc > 1)
{
std::cerr << "too many arguments" << std::endl;
return 1;
}
unsigned int documentSize = 100;
strus::local_ptr<strus::PatternMatcherInterface> pt( strus::createPatternMatcher_std( g_errorBuffer));
if (!pt.get()) throw std::runtime_error("failed to create pattern matcher");
strus::local_ptr<strus::PatternMatcherInstanceInterface> ptinst( pt->createInstance());
if (!ptinst.get()) throw std::runtime_error("failed to create pattern matcher instance");
createPatterns( ptinst.get(), testPatterns);
ptinst->compile();
if (g_errorBuffer->hasError())
{
throw std::runtime_error( "error creating automaton for evaluating rules");
}
Document doc = createDocument( 1, documentSize);
std::cerr << "starting rule evaluation ..." << std::endl;
// Evaluate results:
std::vector<strus::analyzer::PatternMatcherResult>
results = processDocument( ptinst.get(), doc);
// Verify results:
std::vector<strus::analyzer::PatternMatcherResult>::const_iterator
ri = results.begin(), re = results.end();
typedef std::pair<std::string,unsigned int> Match;
std::set<Match> matches;
for (;ri != re; ++ri)
{
matches.insert( Match( ri->name(), ri->ordpos()));
}
std::set<Match>::const_iterator li = matches.begin(), le = matches.end();
for (; li != le; ++li)
{
std::cout << "MATCH " << li->first << " -> " << li->second << std::endl;
}
unsigned int ti=0;
for (; testPatterns[ti].name; ++ti)
{
unsigned int ei=0;
for (; testPatterns[ti].results[ei]; ++ei)
{
std::cout << "CHECK " << ti << ": " << testPatterns[ti].name << " -> " << testPatterns[ti].results[ei] << std::endl;
std::set<Match>::iterator
mi = matches.find( Match( testPatterns[ti].name, testPatterns[ti].results[ei]));
if (mi == matches.end())
{
char numbuf[ 64];
::snprintf( numbuf, sizeof(numbuf), "%u", testPatterns[ti].results[ei]);
throw std::runtime_error( std::string("expected match not found '") + testPatterns[ti].name + "' at ordpos " + numbuf);
}
else
{
matches.erase( mi);
}
}
}
if (!matches.empty())
{
std::set<Match>::const_iterator mi = matches.begin(), me = matches.end();
for (; mi != me; ++mi)
{
std::cerr << "unexpected match of '" << mi->first << "' at ordpos " << mi->second << std::endl;
}
throw std::runtime_error( "more matches found than expected");
}
if (g_errorBuffer->hasError())
{
throw std::runtime_error("error matching rule");
}
std::cerr << "OK" << std::endl;
delete g_errorBuffer;
return 0;
}
catch (const std::runtime_error& err)
{
if (g_errorBuffer->hasError())
{
std::cerr << "error processing pattern matching: "
<< g_errorBuffer->fetchError() << " (" << err.what()
<< ")" << std::endl;
}
else
{
std::cerr << "error processing pattern matching: "
<< err.what() << std::endl;
}
}
catch (const std::bad_alloc&)
{
std::cerr << "out of memory processing pattern matching" << std::endl;
}
delete g_errorBuffer;
return -1;
}
