krageon
/
openmw-tes3coop
forked from teamnwah/openmw-tes3coop
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

purge the rest of boost::shared and any other boost related things that no longer are required

Browse Source 
put boost system back in, clean others up

revert Qt

add back boost fstream
0.6.1
Bret Curtis 8 years ago
parent d785344fad
commit 39185e6f8c
38 changed files with 131 additions and 152 deletions
Show Stats Download Patch File Download Diff File

2
.travis.yml
Unescape Escape View File

@ -32,7 +32,7 @@ addons:
# Tests # Tests
libgtest-dev, google-mock, libgtest-dev, google-mock,
# Boost # Boost
libboost-filesystem-dev, libboost-program-options-dev, libboost-system-dev, libboost-thread-dev, libboost-filesystem-dev, libboost-program-options-dev, libboost-system-dev,
# FFmpeg # FFmpeg
libavcodec-dev, libavformat-dev, libavutil-dev, libswscale-dev, libavcodec-dev, libavformat-dev, libavutil-dev, libswscale-dev,
# Audio & Video # Audio & Video

1
apps/bsatool/bsatool.cpp
Unescape Escape View File

@ -1,7 +1,6 @@
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <vector> #include <vector>
#include <exception>
#include <boost/program_options.hpp> #include <boost/program_options.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>

72
apps/essimporter/importer.cpp
Unescape Escape View File

@ -1,8 +1,8 @@
#include "importer.hpp" #include "importer.hpp"
#include <iomanip> #include <iomanip>
#include <utility>
#include <boost/shared_ptr.hpp>
#include <osgDB/ReadFile> #include <osgDB/ReadFile>
#include <osg/ImageUtils> #include <osg/ImageUtils>
@ -272,37 +272,37 @@ namespace ESSImport
const unsigned int recGAME = ESM::FourCC<'G','A','M','E'>::value; const unsigned int recGAME = ESM::FourCC<'G','A','M','E'>::value;
const unsigned int recJOUR = ESM::FourCC<'J','O','U','R'>::value; const unsigned int recJOUR = ESM::FourCC<'J','O','U','R'>::value;
std::map<unsigned int, boost::shared_ptr<Converter> > converters; std::map<unsigned int, std::shared_ptr<Converter> > converters;
converters[ESM::REC_GLOB] = boost::shared_ptr<Converter>(new ConvertGlobal()); converters[ESM::REC_GLOB] = std::shared_ptr<Converter>(new ConvertGlobal());
converters[ESM::REC_BOOK] = boost::shared_ptr<Converter>(new ConvertBook()); converters[ESM::REC_BOOK] = std::shared_ptr<Converter>(new ConvertBook());
converters[ESM::REC_NPC_] = boost::shared_ptr<Converter>(new ConvertNPC()); converters[ESM::REC_NPC_] = std::shared_ptr<Converter>(new ConvertNPC());
converters[ESM::REC_CREA] = boost::shared_ptr<Converter>(new ConvertCREA()); converters[ESM::REC_CREA] = std::shared_ptr<Converter>(new ConvertCREA());
converters[ESM::REC_NPCC] = boost::shared_ptr<Converter>(new ConvertNPCC()); converters[ESM::REC_NPCC] = std::shared_ptr<Converter>(new ConvertNPCC());
converters[ESM::REC_CREC] = boost::shared_ptr<Converter>(new ConvertCREC()); converters[ESM::REC_CREC] = std::shared_ptr<Converter>(new ConvertCREC());
converters[recREFR ] = boost::shared_ptr<Converter>(new ConvertREFR()); converters[recREFR ] = std::shared_ptr<Converter>(new ConvertREFR());
converters[recPCDT ] = boost::shared_ptr<Converter>(new ConvertPCDT()); converters[recPCDT ] = std::shared_ptr<Converter>(new ConvertPCDT());
converters[recFMAP ] = boost::shared_ptr<Converter>(new ConvertFMAP()); converters[recFMAP ] = std::shared_ptr<Converter>(new ConvertFMAP());
converters[recKLST ] = boost::shared_ptr<Converter>(new ConvertKLST()); converters[recKLST ] = std::shared_ptr<Converter>(new ConvertKLST());
converters[recSTLN ] = boost::shared_ptr<Converter>(new ConvertSTLN()); converters[recSTLN ] = std::shared_ptr<Converter>(new ConvertSTLN());
converters[recGAME ] = boost::shared_ptr<Converter>(new ConvertGAME()); converters[recGAME ] = std::shared_ptr<Converter>(new ConvertGAME());
converters[ESM::REC_CELL] = boost::shared_ptr<Converter>(new ConvertCell()); converters[ESM::REC_CELL] = std::shared_ptr<Converter>(new ConvertCell());
converters[ESM::REC_ALCH] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Potion>()); converters[ESM::REC_ALCH] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Potion>());
converters[ESM::REC_CLAS] = boost::shared_ptr<Converter>(new ConvertClass()); converters[ESM::REC_CLAS] = std::shared_ptr<Converter>(new ConvertClass());
converters[ESM::REC_SPEL] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Spell>()); converters[ESM::REC_SPEL] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Spell>());
converters[ESM::REC_ARMO] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Armor>()); converters[ESM::REC_ARMO] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Armor>());
converters[ESM::REC_WEAP] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Weapon>()); converters[ESM::REC_WEAP] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Weapon>());
converters[ESM::REC_CLOT] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Clothing>()); converters[ESM::REC_CLOT] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Clothing>());
converters[ESM::REC_ENCH] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Enchantment>()); converters[ESM::REC_ENCH] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Enchantment>());
converters[ESM::REC_WEAP] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::Weapon>()); converters[ESM::REC_WEAP] = std::shared_ptr<Converter>(new DefaultConverter<ESM::Weapon>());
converters[ESM::REC_LEVC] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::CreatureLevList>()); converters[ESM::REC_LEVC] = std::shared_ptr<Converter>(new DefaultConverter<ESM::CreatureLevList>());
converters[ESM::REC_LEVI] = boost::shared_ptr<Converter>(new DefaultConverter<ESM::ItemLevList>()); converters[ESM::REC_LEVI] = std::shared_ptr<Converter>(new DefaultConverter<ESM::ItemLevList>());
converters[ESM::REC_CNTC] = boost::shared_ptr<Converter>(new ConvertCNTC()); converters[ESM::REC_CNTC] = std::shared_ptr<Converter>(new ConvertCNTC());
converters[ESM::REC_FACT] = boost::shared_ptr<Converter>(new ConvertFACT()); converters[ESM::REC_FACT] = std::shared_ptr<Converter>(new ConvertFACT());
converters[ESM::REC_INFO] = boost::shared_ptr<Converter>(new ConvertINFO()); converters[ESM::REC_INFO] = std::shared_ptr<Converter>(new ConvertINFO());
converters[ESM::REC_DIAL] = boost::shared_ptr<Converter>(new ConvertDIAL()); converters[ESM::REC_DIAL] = std::shared_ptr<Converter>(new ConvertDIAL());
converters[ESM::REC_QUES] = boost::shared_ptr<Converter>(new ConvertQUES()); converters[ESM::REC_QUES] = std::shared_ptr<Converter>(new ConvertQUES());
converters[recJOUR ] = boost::shared_ptr<Converter>(new ConvertJOUR()); converters[recJOUR ] = std::shared_ptr<Converter>(new ConvertJOUR());
converters[ESM::REC_SCPT] = boost::shared_ptr<Converter>(new ConvertSCPT()); converters[ESM::REC_SCPT] = std::shared_ptr<Converter>(new ConvertSCPT());
// TODO: // TODO:
// - REGN (weather in certain regions?) // - REGN (weather in certain regions?)
@ -312,7 +312,7 @@ namespace ESSImport
std::set<unsigned int> unknownRecords; std::set<unsigned int> unknownRecords;
for (std::map<unsigned int, boost::shared_ptr<Converter> >::const_iterator it = converters.begin(); for (std::map<unsigned int, std::shared_ptr<Converter> >::const_iterator it = converters.begin();
it != converters.end(); ++it) it != converters.end(); ++it)
{ {
it->second->setContext(context); it->second->setContext(context);
@ -323,7 +323,7 @@ namespace ESSImport
ESM::NAME n = esm.getRecName(); ESM::NAME n = esm.getRecName();
esm.getRecHeader(); esm.getRecHeader();
std::map<unsigned int, boost::shared_ptr<Converter> >::iterator it = converters.find(n.intval); std::map<unsigned int, std::shared_ptr<Converter> >::iterator it = converters.find(n.intval);
if (it != converters.end()) if (it != converters.end())
{ {
it->second->read(esm); it->second->read(esm);
@ -386,7 +386,7 @@ namespace ESSImport
// Writing order should be Dynamic Store -> Cells -> Player, // Writing order should be Dynamic Store -> Cells -> Player,
// so that references to dynamic records can be recognized when loading // so that references to dynamic records can be recognized when loading
for (std::map<unsigned int, boost::shared_ptr<Converter> >::const_iterator it = converters.begin(); for (std::map<unsigned int, std::shared_ptr<Converter> >::const_iterator it = converters.begin();
it != converters.end(); ++it) it != converters.end(); ++it)
{ {
if (it->second->getStage() != 0) if (it->second->getStage() != 0)
@ -399,7 +399,7 @@ namespace ESSImport
context.mPlayerBase.save(writer); context.mPlayerBase.save(writer);
writer.endRecord(ESM::REC_NPC_); writer.endRecord(ESM::REC_NPC_);
for (std::map<unsigned int, boost::shared_ptr<Converter> >::const_iterator it = converters.begin(); for (std::map<unsigned int, std::shared_ptr<Converter> >::const_iterator it = converters.begin();
it != converters.end(); ++it) it != converters.end(); ++it)
{ {
if (it->second->getStage() != 1) if (it->second->getStage() != 1)

1
apps/opencs/model/doc/document.hpp
Unescape Escape View File

@ -3,7 +3,6 @@
#include <string> #include <string>
#include <boost/shared_ptr.hpp>
#include <boost/filesystem/path.hpp> #include <boost/filesystem/path.hpp>
#include <QUndoStack> #include <QUndoStack>

2
apps/opencs/model/filter/andnode.cpp
Unescape Escape View File

@ -2,7 +2,7 @@
#include <sstream> #include <sstream>
CSMFilter::AndNode::AndNode (const std::vector<boost::shared_ptr<Node> >& nodes) CSMFilter::AndNode::AndNode (const std::vector<std::shared_ptr<Node> >& nodes)
: NAryNode (nodes, "and") : NAryNode (nodes, "and")
{} {}

2
apps/opencs/model/filter/andnode.hpp
Unescape Escape View File

@ -9,7 +9,7 @@ namespace CSMFilter
{ {
public: public:
AndNode (const std::vector<boost::shared_ptr<Node> >& nodes); AndNode (const std::vector<std::shared_ptr<Node> >& nodes);
virtual bool test (const CSMWorld::IdTableBase& table, int row, virtual bool test (const CSMWorld::IdTableBase& table, int row,
const std::map<int, int>& columns) const; const std::map<int, int>& columns) const;

4
apps/opencs/model/filter/narynode.cpp
Unescape Escape View File

@ -2,7 +2,7 @@
#include <sstream> #include <sstream>
CSMFilter::NAryNode::NAryNode (const std::vector<boost::shared_ptr<Node> >& nodes, CSMFilter::NAryNode::NAryNode (const std::vector<std::shared_ptr<Node> >& nodes,
const std::string& name) const std::string& name)
: mNodes (nodes), mName (name) : mNodes (nodes), mName (name)
{} {}
@ -21,7 +21,7 @@ std::vector<int> CSMFilter::NAryNode::getReferencedColumns() const
{ {
std::vector<int> columns; std::vector<int> columns;
for (std::vector<boost::shared_ptr<Node> >::const_iterator iter (mNodes.begin()); for (std::vector<std::shared_ptr<Node> >::const_iterator iter (mNodes.begin());
iter!=mNodes.end(); ++iter) iter!=mNodes.end(); ++iter)
{ {
std::vector<int> columns2 = (*iter)->getReferencedColumns(); std::vector<int> columns2 = (*iter)->getReferencedColumns();

6
apps/opencs/model/filter/narynode.hpp
Unescape Escape View File

@ -4,20 +4,18 @@
#include <vector> #include <vector>
#include <string> #include <string>
#include <boost/shared_ptr.hpp>
#include "node.hpp" #include "node.hpp"
namespace CSMFilter namespace CSMFilter
{ {
class NAryNode : public Node class NAryNode : public Node
{ {
std::vector<boost::shared_ptr<Node> > mNodes; std::vector<std::shared_ptr<Node> > mNodes;
std::string mName; std::string mName;
public: public:
NAryNode (const std::vector<boost::shared_ptr<Node> >& nodes, const std::string& name); NAryNode (const std::vector<std::shared_ptr<Node> >& nodes, const std::string& name);
int getSize() const; int getSize() const;

5
apps/opencs/model/filter/node.hpp
Unescape Escape View File

@ -3,10 +3,9 @@
#include <string> #include <string>
#include <map> #include <map>
#include <memory>
#include <vector> #include <vector>
#include <boost/shared_ptr.hpp>
#include <QMetaType> #include <QMetaType>
namespace CSMWorld namespace CSMWorld
@ -48,6 +47,6 @@ namespace CSMFilter
}; };
} }
Q_DECLARE_METATYPE (boost::shared_ptr<CSMFilter::Node>) Q_DECLARE_METATYPE (std::shared_ptr<CSMFilter::Node>)
#endif #endif

2
apps/opencs/model/filter/notnode.cpp
Unescape Escape View File

@ -1,6 +1,6 @@
#include "notnode.hpp" #include "notnode.hpp"
CSMFilter::NotNode::NotNode (boost::shared_ptr<Node> child) : UnaryNode (child, "not") {} CSMFilter::NotNode::NotNode (std::shared_ptr<Node> child) : UnaryNode (child, "not") {}
bool CSMFilter::NotNode::test (const CSMWorld::IdTableBase& table, int row, bool CSMFilter::NotNode::test (const CSMWorld::IdTableBase& table, int row,
const std::map<int, int>& columns) const const std::map<int, int>& columns) const

2
apps/opencs/model/filter/notnode.hpp
Unescape Escape View File

@ -9,7 +9,7 @@ namespace CSMFilter
{ {
public: public:
NotNode (boost::shared_ptr<Node> child); NotNode (std::shared_ptr<Node> child);
virtual bool test (const CSMWorld::IdTableBase& table, int row, virtual bool test (const CSMWorld::IdTableBase& table, int row,
const std::map<int, int>& columns) const; const std::map<int, int>& columns) const;

2
apps/opencs/model/filter/ornode.cpp
Unescape Escape View File

@ -2,7 +2,7 @@
#include <sstream> #include <sstream>
CSMFilter::OrNode::OrNode (const std::vector<boost::shared_ptr<Node> >& nodes) CSMFilter::OrNode::OrNode (const std::vector<std::shared_ptr<Node> >& nodes)
: NAryNode (nodes, "or") : NAryNode (nodes, "or")
{} {}

2
apps/opencs/model/filter/ornode.hpp
Unescape Escape View File

@ -9,7 +9,7 @@ namespace CSMFilter
{ {
public: public:
OrNode (const std::vector<boost::shared_ptr<Node> >& nodes); OrNode (const std::vector<std::shared_ptr<Node> >& nodes);
virtual bool test (const CSMWorld::IdTableBase& table, int row, virtual bool test (const CSMWorld::IdTableBase& table, int row,
const std::map<int, int>& columns) const; const std::map<int, int>& columns) const;

78
apps/opencs/model/filter/parser.cpp
Unescape Escape View File

@ -235,7 +235,7 @@ CSMFilter::Token CSMFilter::Parser::getNextToken()
return Token (Token::Type_None); return Token (Token::Type_None);
} }
boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty, bool ignoreOneShot) std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty, bool ignoreOneShot)
{ {
if (Token token = getNextToken()) if (Token token = getNextToken())
{ {
@ -247,11 +247,11 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty,
{ {
case Token::Type_Keyword_True: case Token::Type_Keyword_True:
return boost::shared_ptr<CSMFilter::Node> (new BooleanNode (true)); return std::shared_ptr<CSMFilter::Node> (new BooleanNode (true));
case Token::Type_Keyword_False: case Token::Type_Keyword_False:
return boost::shared_ptr<CSMFilter::Node> (new BooleanNode (false)); return std::shared_ptr<CSMFilter::Node> (new BooleanNode (false));
case Token::Type_Keyword_And: case Token::Type_Keyword_And:
case Token::Type_Keyword_Or: case Token::Type_Keyword_Or:
@ -260,12 +260,12 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty,
case Token::Type_Keyword_Not: case Token::Type_Keyword_Not:
{ {
boost::shared_ptr<CSMFilter::Node> node = parseImp(); std::shared_ptr<CSMFilter::Node> node = parseImp();
if (mError) if (mError)
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
return boost::shared_ptr<CSMFilter::Node> (new NotNode (node)); return std::shared_ptr<CSMFilter::Node> (new NotNode (node));
} }
case Token::Type_Keyword_Text: case Token::Type_Keyword_Text:
@ -281,7 +281,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty,
if (!allowEmpty) if (!allowEmpty)
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
default: default:
@ -289,27 +289,27 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty,
} }
} }
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseNAry (const Token& keyword) std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseNAry (const Token& keyword)
{ {
std::vector<boost::shared_ptr<Node> > nodes; std::vector<std::shared_ptr<Node> > nodes;
Token token = getNextToken(); Token token = getNextToken();
if (token.mType!=Token::Type_Open) if (token.mType!=Token::Type_Open)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
for (;;) for (;;)
{ {
boost::shared_ptr<Node> node = parseImp(); std::shared_ptr<Node> node = parseImp();
if (mError) if (mError)
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
nodes.push_back (node); nodes.push_back (node);
@ -318,7 +318,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseNAry (const Token& ke
if (!token || (token.mType!=Token::Type_Close && token.mType!=Token::Type_Comma)) if (!token || (token.mType!=Token::Type_Close && token.mType!=Token::Type_Comma))
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
if (token.mType==Token::Type_Close) if (token.mType==Token::Type_Close)
@ -328,31 +328,31 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseNAry (const Token& ke
if (nodes.empty()) if (nodes.empty())
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
switch (keyword.mType) switch (keyword.mType)
{ {
case Token::Type_Keyword_And: return boost::shared_ptr<CSMFilter::Node> (new AndNode (nodes)); case Token::Type_Keyword_And: return std::shared_ptr<CSMFilter::Node> (new AndNode (nodes));
case Token::Type_Keyword_Or: return boost::shared_ptr<CSMFilter::Node> (new OrNode (nodes)); case Token::Type_Keyword_Or: return std::shared_ptr<CSMFilter::Node> (new OrNode (nodes));
default: error(); return boost::shared_ptr<Node>(); default: error(); return std::shared_ptr<Node>();
} }
} }
boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText() std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText()
{ {
Token token = getNextToken(); Token token = getNextToken();
if (token.mType!=Token::Type_Open) if (token.mType!=Token::Type_Open)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
token = getNextToken(); token = getNextToken();
if (!token) if (!token)
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
// parse column ID // parse column ID
int columnId = -1; int columnId = -1;
@ -370,7 +370,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText()
if (columnId<0) if (columnId<0)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
token = getNextToken(); token = getNextToken();
@ -378,7 +378,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText()
if (token.mType!=Token::Type_Comma) if (token.mType!=Token::Type_Comma)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
// parse text pattern // parse text pattern
@ -387,7 +387,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText()
if (!token.isString()) if (!token.isString())
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
std::string text = token.mString; std::string text = token.mString;
@ -397,26 +397,26 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText()
if (token.mType!=Token::Type_Close) if (token.mType!=Token::Type_Close)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
return boost::shared_ptr<Node> (new TextNode (columnId, text)); return std::shared_ptr<Node> (new TextNode (columnId, text));
} }
boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue() std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
{ {
Token token = getNextToken(); Token token = getNextToken();
if (token.mType!=Token::Type_Open) if (token.mType!=Token::Type_Open)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
token = getNextToken(); token = getNextToken();
if (!token) if (!token)
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
// parse column ID // parse column ID
int columnId = -1; int columnId = -1;
@ -434,7 +434,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
if (columnId<0) if (columnId<0)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
token = getNextToken(); token = getNextToken();
@ -442,7 +442,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
if (token.mType!=Token::Type_Comma) if (token.mType!=Token::Type_Comma)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
// parse value // parse value
@ -467,7 +467,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
else if (token.mType!=Token::Type_CloseSquare && token.mType!=Token::Type_Open) else if (token.mType!=Token::Type_CloseSquare && token.mType!=Token::Type_Open)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
token = getNextToken(); token = getNextToken();
@ -481,7 +481,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
if (token.mType!=Token::Type_Comma) if (token.mType!=Token::Type_Comma)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
} }
else if (token.mType==Token::Type_Comma) else if (token.mType==Token::Type_Comma)
@ -491,7 +491,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
else else
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
token = getNextToken(); token = getNextToken();
@ -513,7 +513,7 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
else if (token.mType!=Token::Type_OpenSquare && token.mType!=Token::Type_Close) else if (token.mType!=Token::Type_OpenSquare && token.mType!=Token::Type_Close)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
} }
@ -522,10 +522,10 @@ boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
if (token.mType!=Token::Type_Close) if (token.mType!=Token::Type_Close)
{ {
error(); error();
return boost::shared_ptr<Node>(); return std::shared_ptr<Node>();
} }
return boost::shared_ptr<Node> (new ValueNode (columnId, lowerType, upperType, lower, upper)); return std::shared_ptr<Node> (new ValueNode (columnId, lowerType, upperType, lower, upper));
} }
void CSMFilter::Parser::error() void CSMFilter::Parser::error()
@ -556,7 +556,7 @@ bool CSMFilter::Parser::parse (const std::string& filter, bool allowPredefined)
} }
else if (!allowPredefined || token==Token (Token::Type_OneShot)) else if (!allowPredefined || token==Token (Token::Type_OneShot))
{ {
boost::shared_ptr<Node> node = parseImp (true, token!=Token (Token::Type_OneShot)); std::shared_ptr<Node> node = parseImp (true, token!=Token (Token::Type_OneShot));
if (mError) if (mError)
return false; return false;
@ -612,7 +612,7 @@ bool CSMFilter::Parser::parse (const std::string& filter, bool allowPredefined)
} }
} }
boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::getFilter() const std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::getFilter() const
{ {
if (mError) if (mError)
throw std::logic_error ("No filter available"); throw std::logic_error ("No filter available");

14
apps/opencs/model/filter/parser.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef CSM_FILTER_PARSER_H #ifndef CSM_FILTER_PARSER_H
#define CSM_FILTER_PARSER_H #define CSM_FILTER_PARSER_H
#include <boost/shared_ptr.hpp>
#include "node.hpp" #include "node.hpp"
namespace CSMWorld namespace CSMWorld
@ -16,7 +14,7 @@ namespace CSMFilter
class Parser class Parser
{ {
boost::shared_ptr<Node> mFilter; std::shared_ptr<Node> mFilter;
std::string mInput; std::string mInput;
int mIndex; int mIndex;
bool mError; bool mError;
@ -31,14 +29,14 @@ namespace CSMFilter
Token checkKeywords (const Token& token); Token checkKeywords (const Token& token);
///< Turn string token into keyword token, if possible. ///< Turn string token into keyword token, if possible.
boost::shared_ptr<Node> parseImp (bool allowEmpty = false, bool ignoreOneShot = false); std::shared_ptr<Node> parseImp (bool allowEmpty = false, bool ignoreOneShot = false);
///< Will return a null-pointer, if there is nothing more to parse. ///< Will return a null-pointer, if there is nothing more to parse.
boost::shared_ptr<Node> parseNAry (const Token& keyword); std::shared_ptr<Node> parseNAry (const Token& keyword);
boost::shared_ptr<Node> parseText(); std::shared_ptr<Node> parseText();
boost::shared_ptr<Node> parseValue(); std::shared_ptr<Node> parseValue();
void error(); void error();
@ -51,7 +49,7 @@ namespace CSMFilter
/// ///
/// \return Success? /// \return Success?
boost::shared_ptr<Node> getFilter() const; std::shared_ptr<Node> getFilter() const;
///< Throws an exception if the last call to parse did not return true. ///< Throws an exception if the last call to parse did not return true.
}; };
} }

2
apps/opencs/model/filter/unarynode.cpp
Unescape Escape View File

@ -1,6 +1,6 @@
#include "unarynode.hpp" #include "unarynode.hpp"
CSMFilter::UnaryNode::UnaryNode (boost::shared_ptr<Node> child, const std::string& name) CSMFilter::UnaryNode::UnaryNode (std::shared_ptr<Node> child, const std::string& name)
: mChild (child), mName (name) : mChild (child), mName (name)
{} {}

6
apps/opencs/model/filter/unarynode.hpp
Unescape Escape View File

@ -1,20 +1,18 @@
#ifndef CSM_FILTER_UNARYNODE_H #ifndef CSM_FILTER_UNARYNODE_H
#define CSM_FILTER_UNARYNODE_H #define CSM_FILTER_UNARYNODE_H
#include <boost/shared_ptr.hpp>
#include "node.hpp" #include "node.hpp"
namespace CSMFilter namespace CSMFilter
{ {
class UnaryNode : public Node class UnaryNode : public Node
{ {
boost::shared_ptr<Node> mChild; std::shared_ptr<Node> mChild;
std::string mName; std::string mName;
public: public:
UnaryNode (boost::shared_ptr<Node> child, const std::string& name); UnaryNode (std::shared_ptr<Node> child, const std::string& name);
const Node& getChild() const; const Node& getChild() const;

8
apps/opencs/model/world/data.cpp
Unescape Escape View File

@ -554,12 +554,12 @@ CSMWorld::Data::~Data()
delete mReader; delete mReader;
} }
boost::shared_ptr<Resource::ResourceSystem> CSMWorld::Data::getResourceSystem() std::shared_ptr<Resource::ResourceSystem> CSMWorld::Data::getResourceSystem()
{ {
return mResourceSystem; return mResourceSystem;
} }
boost::shared_ptr<const Resource::ResourceSystem> CSMWorld::Data::getResourceSystem() const std::shared_ptr<const Resource::ResourceSystem> CSMWorld::Data::getResourceSystem() const
{ {
return mResourceSystem; return mResourceSystem;
} }
@ -891,7 +891,7 @@ void CSMWorld::Data::merge()
int CSMWorld::Data::startLoading (const boost::filesystem::path& path, bool base, bool project) int CSMWorld::Data::startLoading (const boost::filesystem::path& path, bool base, bool project)
{ {
// Don't delete the Reader yet. Some record types store a reference to the Reader to handle on-demand loading // Don't delete the Reader yet. Some record types store a reference to the Reader to handle on-demand loading
boost::shared_ptr<ESM::ESMReader> ptr(mReader); std::shared_ptr<ESM::ESMReader> ptr(mReader);
mReaders.push_back(ptr); mReaders.push_back(ptr);
mReader = 0; mReader = 0;
@ -945,7 +945,7 @@ bool CSMWorld::Data::continueLoading (CSMDoc::Messages& messages)
// Don't delete the Reader yet. Some record types store a reference to the Reader to handle on-demand loading. // Don't delete the Reader yet. Some record types store a reference to the Reader to handle on-demand loading.
// We don't store non-base reader, because everything going into modified will be // We don't store non-base reader, because everything going into modified will be
// fully loaded during the initial loading process. // fully loaded during the initial loading process.
boost::shared_ptr<ESM::ESMReader> ptr(mReader); std::shared_ptr<ESM::ESMReader> ptr(mReader);
mReaders.push_back(ptr); mReaders.push_back(ptr);
} }
else else

8
apps/opencs/model/world/data.hpp
Unescape Escape View File

@ -119,9 +119,9 @@ namespace CSMWorld
std::map<std::string, std::map<ESM::RefNum, std::string> > mRefLoadCache; std::map<std::string, std::map<ESM::RefNum, std::string> > mRefLoadCache;
int mReaderIndex; int mReaderIndex;
boost::shared_ptr<Resource::ResourceSystem> mResourceSystem; std::shared_ptr<Resource::ResourceSystem> mResourceSystem;
std::vector<boost::shared_ptr<ESM::ESMReader> > mReaders; std::vector<std::shared_ptr<ESM::ESMReader> > mReaders;
std::map<std::string, int> mContentFileNames; std::map<std::string, int> mContentFileNames;
@ -148,9 +148,9 @@ namespace CSMWorld
const Fallback::Map* getFallbackMap() const; const Fallback::Map* getFallbackMap() const;
boost::shared_ptr<Resource::ResourceSystem> getResourceSystem(); std::shared_ptr<Resource::ResourceSystem> getResourceSystem();
boost::shared_ptr<const Resource::ResourceSystem> getResourceSystem() const; std::shared_ptr<const Resource::ResourceSystem> getResourceSystem() const;
const IdCollection<ESM::Global>& getGlobals() const; const IdCollection<ESM::Global>& getGlobals() const;

4
apps/opencs/model/world/idcompletionmanager.cpp
Unescape Escape View File

@ -77,7 +77,7 @@ bool CSMWorld::IdCompletionManager::hasCompleterFor(CSMWorld::ColumnBase::Displa
return mCompleters.find(display) != mCompleters.end(); return mCompleters.find(display) != mCompleters.end();
} }
boost::shared_ptr<QCompleter> CSMWorld::IdCompletionManager::getCompleter(CSMWorld::ColumnBase::Display display) std::shared_ptr<QCompleter> CSMWorld::IdCompletionManager::getCompleter(CSMWorld::ColumnBase::Display display)
{ {
if (!hasCompleterFor(display)) if (!hasCompleterFor(display))
{ {
@ -99,7 +99,7 @@ void CSMWorld::IdCompletionManager::generateCompleters(CSMWorld::Data &data)
int idColumn = table->searchColumnIndex(CSMWorld::Columns::ColumnId_Id); int idColumn = table->searchColumnIndex(CSMWorld::Columns::ColumnId_Id);
if (idColumn != -1) if (idColumn != -1)
{ {
boost::shared_ptr<QCompleter> completer = boost::make_shared<QCompleter>(table); std::shared_ptr<QCompleter> completer = std::make_shared<QCompleter>(table);
completer->setCompletionColumn(idColumn); completer->setCompletionColumn(idColumn);
// The completion role must be Qt::DisplayRole to get the ID values from the model // The completion role must be Qt::DisplayRole to get the ID values from the model
completer->setCompletionRole(Qt::DisplayRole); completer->setCompletionRole(Qt::DisplayRole);

7
apps/opencs/model/world/idcompletionmanager.hpp
Unescape Escape View File

@ -3,8 +3,7 @@
#include <vector> #include <vector>
#include <map> #include <map>
#include <memory>
#include <boost/shared_ptr.hpp>
#include "columnbase.hpp" #include "columnbase.hpp"
#include "universalid.hpp" #include "universalid.hpp"
@ -20,7 +19,7 @@ namespace CSMWorld
{ {
static const std::map<ColumnBase::Display, UniversalId::Type> sCompleterModelTypes; static const std::map<ColumnBase::Display, UniversalId::Type> sCompleterModelTypes;
std::map<ColumnBase::Display, boost::shared_ptr<QCompleter> > mCompleters; std::map<ColumnBase::Display, std::shared_ptr<QCompleter> > mCompleters;
// Don't allow copying // Don't allow copying
IdCompletionManager(const IdCompletionManager &); IdCompletionManager(const IdCompletionManager &);
@ -34,7 +33,7 @@ namespace CSMWorld
IdCompletionManager(Data &data); IdCompletionManager(Data &data);
bool hasCompleterFor(ColumnBase::Display display) const; bool hasCompleterFor(ColumnBase::Display display) const;
boost::shared_ptr<QCompleter> getCompleter(ColumnBase::Display display); std::shared_ptr<QCompleter> getCompleter(ColumnBase::Display display);
}; };
} }

2
apps/opencs/model/world/idtableproxymodel.cpp
Unescape Escape View File

@ -82,7 +82,7 @@ void CSMWorld::IdTableProxyModel::setSourceModel(QAbstractItemModel *model)
SLOT(sourceDataChanged(const QModelIndex &, const QModelIndex &))); SLOT(sourceDataChanged(const QModelIndex &, const QModelIndex &)));
} }
void CSMWorld::IdTableProxyModel::setFilter (const boost::shared_ptr<CSMFilter::Node>& filter) void CSMWorld::IdTableProxyModel::setFilter (const std::shared_ptr<CSMFilter::Node>& filter)
{ {
beginResetModel(); beginResetModel();
mFilter = filter; mFilter = filter;

6
apps/opencs/model/world/idtableproxymodel.hpp
Unescape Escape View File

@ -3,8 +3,6 @@
#include <string> #include <string>
#include <boost/shared_ptr.hpp>
#include <map> #include <map>
#include <QSortFilterProxyModel> #include <QSortFilterProxyModel>
@ -19,7 +17,7 @@ namespace CSMWorld
{ {
Q_OBJECT Q_OBJECT
boost::shared_ptr<CSMFilter::Node> mFilter; std::shared_ptr<CSMFilter::Node> mFilter;
std::map<int, int> mColumnMap; // column ID, column index in this model (or -1) std::map<int, int> mColumnMap; // column ID, column index in this model (or -1)
// Cache of enum values for enum columns (e.g. Modified, Record Type). // Cache of enum values for enum columns (e.g. Modified, Record Type).
@ -43,7 +41,7 @@ namespace CSMWorld
virtual void setSourceModel(QAbstractItemModel *model); virtual void setSourceModel(QAbstractItemModel *model);
void setFilter (const boost::shared_ptr<CSMFilter::Node>& filter); void setFilter (const std::shared_ptr<CSMFilter::Node>& filter);
void refreshFilter(); void refreshFilter();

4
apps/opencs/view/filter/editwidget.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef CSV_FILTER_EDITWIDGET_H #ifndef CSV_FILTER_EDITWIDGET_H
#define CSV_FILTER_EDITWIDGET_H #define CSV_FILTER_EDITWIDGET_H
#include <boost/shared_ptr.hpp>
#include <QLineEdit> #include <QLineEdit>
#include <QPalette> #include <QPalette>
#include <QtCore/qnamespace.h> #include <QtCore/qnamespace.h>
@ -38,7 +36,7 @@ namespace CSVFilter
signals: signals:
void filterChanged (boost::shared_ptr<CSMFilter::Node> filter); void filterChanged (std::shared_ptr<CSMFilter::Node> filter);
private: private:
std::string generateFilter(std::pair<std::string, std::vector<std::string> >& seekedString) const; std::string generateFilter(std::pair<std::string, std::vector<std::string> >& seekedString) const;

4
apps/opencs/view/filter/filterbox.cpp
Unescape Escape View File

@ -21,8 +21,8 @@ CSVFilter::FilterBox::FilterBox (CSMWorld::Data& data, QWidget *parent)
setLayout (layout); setLayout (layout);
connect (mRecordFilterBox, connect (mRecordFilterBox,
SIGNAL (filterChanged (boost::shared_ptr<CSMFilter::Node>)), SIGNAL (filterChanged (std::shared_ptr<CSMFilter::Node>)),
this, SIGNAL (recordFilterChanged (boost::shared_ptr<CSMFilter::Node>))); this, SIGNAL (recordFilterChanged (std::shared_ptr<CSMFilter::Node>)));
setAcceptDrops(true); setAcceptDrops(true);
} }

2
apps/opencs/view/filter/filterbox.hpp
Unescape Escape View File

@ -41,7 +41,7 @@ namespace CSVFilter
void dragMoveEvent(QDragMoveEvent *event); void dragMoveEvent(QDragMoveEvent *event);
signals: signals:
void recordFilterChanged (boost::shared_ptr<CSMFilter::Node> filter); void recordFilterChanged (std::shared_ptr<CSMFilter::Node> filter);
void recordDropped (std::vector<CSMWorld::UniversalId>& types, Qt::DropAction action); void recordDropped (std::vector<CSMWorld::UniversalId>& types, Qt::DropAction action);
}; };

4
apps/opencs/view/filter/recordfilterbox.cpp
Unescape Escape View File

@ -23,8 +23,8 @@ CSVFilter::RecordFilterBox::RecordFilterBox (CSMWorld::Data& data, QWidget *pare
setLayout (layout); setLayout (layout);
connect ( connect (
mEdit, SIGNAL (filterChanged (boost::shared_ptr<CSMFilter::Node>)), mEdit, SIGNAL (filterChanged (std::shared_ptr<CSMFilter::Node>)),
this, SIGNAL (filterChanged (boost::shared_ptr<CSMFilter::Node>))); this, SIGNAL (filterChanged (std::shared_ptr<CSMFilter::Node>)));
} }
void CSVFilter::RecordFilterBox::setFilter (const std::string& filter) void CSVFilter::RecordFilterBox::setFilter (const std::string& filter)

4
apps/opencs/view/filter/recordfilterbox.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef CSV_FILTER_RECORDFILTERBOX_H #ifndef CSV_FILTER_RECORDFILTERBOX_H
#define CSV_FILTER_RECORDFILTERBOX_H #define CSV_FILTER_RECORDFILTERBOX_H
#include <boost/shared_ptr.hpp>
#include <QWidget> #include <QWidget>
#include <QtCore/qnamespace.h> #include <QtCore/qnamespace.h>
@ -38,7 +36,7 @@ namespace CSVFilter
signals: signals:
void filterChanged (boost::shared_ptr<CSMFilter::Node> filter); void filterChanged (std::shared_ptr<CSMFilter::Node> filter);
}; };
} }

2
apps/opencs/view/render/object.hpp
Unescape Escape View File

@ -3,8 +3,6 @@
#include <string> #include <string>
#include <boost/shared_ptr.hpp>
#include <osg/ref_ptr> #include <osg/ref_ptr>
#include <osg/Referenced> #include <osg/Referenced>

2
apps/opencs/view/render/scenewidget.cpp
Unescape Escape View File

@ -172,7 +172,7 @@ void CompositeViewer::update()
// --------------------------------------------------- // ---------------------------------------------------
SceneWidget::SceneWidget(boost::shared_ptr<Resource::ResourceSystem> resourceSystem, QWidget *parent, Qt::WindowFlags f, SceneWidget::SceneWidget(std::shared_ptr<Resource::ResourceSystem> resourceSystem, QWidget *parent, Qt::WindowFlags f,
bool retrieveInput) bool retrieveInput)
: RenderWidget(parent, f) : RenderWidget(parent, f)
, mResourceSystem(resourceSystem) , mResourceSystem(resourceSystem)

6
apps/opencs/view/render/scenewidget.hpp
Unescape Escape View File

@ -10,8 +10,6 @@
#include <osgViewer/View> #include <osgViewer/View>
#include <osgViewer/CompositeViewer> #include <osgViewer/CompositeViewer>
#include <boost/shared_ptr.hpp>
#include "lightingday.hpp" #include "lightingday.hpp"
#include "lightingnight.hpp" #include "lightingnight.hpp"
#include "lightingbright.hpp" #include "lightingbright.hpp"
@ -78,7 +76,7 @@ namespace CSVRender
{ {
Q_OBJECT Q_OBJECT
public: public:
SceneWidget(boost::shared_ptr<Resource::ResourceSystem> resourceSystem, QWidget* parent = 0, SceneWidget(std::shared_ptr<Resource::ResourceSystem> resourceSystem, QWidget* parent = 0,
Qt::WindowFlags f = 0, bool retrieveInput = true); Qt::WindowFlags f = 0, bool retrieveInput = true);
virtual ~SceneWidget(); virtual ~SceneWidget();
@ -98,7 +96,7 @@ namespace CSVRender
virtual void mouseMoveEvent (QMouseEvent *event); virtual void mouseMoveEvent (QMouseEvent *event);
virtual void wheelEvent (QWheelEvent *event); virtual void wheelEvent (QWheelEvent *event);
boost::shared_ptr<Resource::ResourceSystem> mResourceSystem; std::shared_ptr<Resource::ResourceSystem> mResourceSystem;
Lighting* mLighting; Lighting* mLighting;

2
apps/opencs/view/render/worldspacewidget.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef OPENCS_VIEW_WORLDSPACEWIDGET_H #ifndef OPENCS_VIEW_WORLDSPACEWIDGET_H
#define OPENCS_VIEW_WORLDSPACEWIDGET_H #define OPENCS_VIEW_WORLDSPACEWIDGET_H
#include <boost/shared_ptr.hpp>
#include <QTimer> #include <QTimer>
#include <osg/Vec3> #include <osg/Vec3>

2
apps/opencs/view/world/table.cpp
Unescape Escape View File

@ -692,7 +692,7 @@ void CSVWorld::Table::requestFocus (const std::string& id)
scrollTo (index, QAbstractItemView::PositionAtTop); scrollTo (index, QAbstractItemView::PositionAtTop);
} }
void CSVWorld::Table::recordFilterChanged (boost::shared_ptr<CSMFilter::Node> filter) void CSVWorld::Table::recordFilterChanged (std::shared_ptr<CSMFilter::Node> filter)
{ {
mProxyModel->setFilter (filter); mProxyModel->setFilter (filter);
tableSizeUpdate(); tableSizeUpdate();

2
apps/opencs/view/world/table.hpp
Unescape Escape View File

@ -151,7 +151,7 @@ namespace CSVWorld
void requestFocus (const std::string& id); void requestFocus (const std::string& id);
void recordFilterChanged (boost::shared_ptr<CSMFilter::Node> filter); void recordFilterChanged (std::shared_ptr<CSMFilter::Node> filter);
void rowAdded(const std::string &id); void rowAdded(const std::string &id);
}; };

4
apps/opencs/view/world/tablesubview.cpp
Unescape Escape View File

@ -78,8 +78,8 @@ CSVWorld::TableSubView::TableSubView (const CSMWorld::UniversalId& id, CSMDoc::D
mTable, SLOT (requestFocus (const std::string&))); mTable, SLOT (requestFocus (const std::string&)));
connect (mFilterBox, connect (mFilterBox,
SIGNAL (recordFilterChanged (boost::shared_ptr<CSMFilter::Node>)), SIGNAL (recordFilterChanged (std::shared_ptr<CSMFilter::Node>)),
mTable, SLOT (recordFilterChanged (boost::shared_ptr<CSMFilter::Node>))); mTable, SLOT (recordFilterChanged (std::shared_ptr<CSMFilter::Node>)));
connect(mFilterBox, SIGNAL(recordDropped(std::vector<CSMWorld::UniversalId>&, Qt::DropAction)), connect(mFilterBox, SIGNAL(recordDropped(std::vector<CSMWorld::UniversalId>&, Qt::DropAction)),
this, SLOT(createFilterRequest(std::vector<CSMWorld::UniversalId>&, Qt::DropAction))); this, SLOT(createFilterRequest(std::vector<CSMWorld::UniversalId>&, Qt::DropAction)));

2
apps/openmw/mwrender/water.cpp
Unescape Escape View File

@ -28,11 +28,9 @@
#include <components/sceneutil/waterutil.hpp> #include <components/sceneutil/waterutil.hpp>
#include <components/nifosg/controller.hpp> #include <components/nifosg/controller.hpp>
#include <components/sceneutil/controller.hpp>
#include <components/shader/shadermanager.hpp> #include <components/shader/shadermanager.hpp>
#include <components/settings/settings.hpp>
#include <components/esm/loadcell.hpp> #include <components/esm/loadcell.hpp>

4
components/contentselector/view/contentselector.cpp
Unescape Escape View File

@ -6,9 +6,11 @@
#include <QMenu> #include <QMenu>
#include <QContextMenuEvent> #include <QContextMenuEvent>
#include <QGridLayout> #include <QGridLayout>
#include <QMessageBox>
#include <QModelIndex>
#include <QDir> #include <QDir>
#include <QtGui/QAbstractItemView>
ContentSelectorView::ContentSelector::ContentSelector(QWidget *parent) : ContentSelectorView::ContentSelector::ContentSelector(QWidget *parent) :
QObject(parent) QObject(parent)

1
extern/osg-ffmpeg-videoplayer/audiodecoder.cpp vendored
Unescape Escape View File

@ -1,6 +1,7 @@
#include "audiodecoder.hpp" #include "audiodecoder.hpp"
#include <stdexcept> #include <stdexcept>
#include <string>
extern "C" extern "C"
{ {

Write Preview
Loading…
Cancel
Save