wxArrayString Extractor::SelectParsable(const wxArrayString& files)
{
wxStringTokenizer tkn(Extensions, ";, \t", wxTOKEN_STRTOK);
wxString wildcard;
wxArrayString result;
size_t i;
while (tkn.HasMoreTokens())
{
wildcard = tkn.GetNextToken();
#ifdef __WXMSW__
wildcard.MakeLower();
#endif
for (i = 0; i < files.GetCount(); i++)
#ifdef __WXMSW__
if (files[i].Lower().Matches(wildcard))
#else
if (files[i].Matches(wildcard))
#endif
{
result.Add(files[i]);
}
}
return result;
}
// find a file in a list of directories, returns false if not found
bool wxFindFileInPath(wxString *pStr, const wxString& szPath, const wxString& szFile)
{
// we assume that it's not empty
wxCHECK_MSG( !szFile.empty(), false,
wxT("empty file name in wxFindFileInPath"));
// skip path separator in the beginning of the file name if present
wxString szFile2;
if ( wxIsPathSeparator(szFile[0u]) )
szFile2 = szFile.Mid(1);
else
szFile2 = szFile;
wxStringTokenizer tkn(szPath, wxPATH_SEP);
while ( tkn.HasMoreTokens() )
{
wxString strFile = tkn.GetNextToken();
if ( !wxEndsWithPathSeparator(strFile) )
strFile += wxFILE_SEP_PATH;
strFile += szFile2;
if ( wxFileExists(strFile) )
{
*pStr = strFile;
return true;
}
}
return false;
}
/////////////
// Read tags
void AssDialogueBlockOverride::ParseTags () {
// Clear current vector
Tags.clear();
// Fix parenthesis matching
while (text.Freq(_T('(')) > text.Freq(_T(')'))) {
text += _T(")");
}
// Initialize tokenizer
wxStringTokenizer tkn(text,_T("\\"),wxTOKEN_RET_EMPTY_ALL);
while (tkn.HasMoreTokens()) {
wxString curTag = _T("\\");
curTag += tkn.GetNextToken();
if (curTag == _T("\\")) continue;
// Check for parenthesis matching
while (curTag.Freq(_T('(')) > curTag.Freq(_T(')'))) {
if (!tkn.HasMoreTokens()) {
wxLogWarning(_T("Unmatched parenthesis! Line contents: ") + parent->Text);
break;
}
curTag << _T("\\") << tkn.GetNextToken();
}
AssOverrideTag *newTag = new AssOverrideTag;
newTag->SetText(curTag);
Tags.push_back(newTag);
}
}
void ExtractorsDB::Read(wxConfigBase *cfg)
{
Data.clear();
cfg->SetExpandEnvVars(false);
Extractor info;
wxString key, oldpath = cfg->GetPath();
wxStringTokenizer tkn(cfg->Read("Parsers/List", wxEmptyString), ";");
while (tkn.HasMoreTokens())
{
info.Name = tkn.GetNextToken();
key = info.Name; key.Replace("/", "_");
cfg->SetPath("Parsers/" + key);
info.Enabled = cfg->ReadBool("Enabled", true);
info.Extensions = cfg->Read("Extensions", wxEmptyString);
info.Command = cfg->Read("Command", wxEmptyString);
info.KeywordItem = cfg->Read("KeywordItem", wxEmptyString);
info.FileItem = cfg->Read("FileItem", wxEmptyString);
info.CharsetItem = cfg->Read("CharsetItem", wxEmptyString);
Data.push_back(info);
cfg->SetPath(oldpath);
}
}
// This routine receives a string containing patches, trims it,
// Then sends the command to be parsed.
void TrimPatches(wxString& s)
{
wxStringTokenizer tkn( s, L"\n" );
while(tkn.HasMoreTokens()) {
inifile_command(0, tkn.GetNextToken());
}
}
/*static*/ wxString CommentDialog::AddStartHash(const wxString& comment)
{
wxString tmpComment;
wxStringTokenizer tkn(comment, _T("\n\r"));
while (tkn.HasMoreTokens())
tmpComment << _T("# ") << tkn.GetNextToken() << _T("\n");
return tmpComment;
}
static void LINKAGEMODE SetTraceMasks()
{
#if wxUSE_LOG
wxString mask;
if ( wxGetEnv(wxT("WXTRACE"), &mask) )
{
wxStringTokenizer tkn(mask, wxT(",;:"));
while ( tkn.HasMoreTokens() )
wxLog::AddTraceMask(tkn.GetNextToken());
}
#endif // wxUSE_LOG
}
void wxFontsManager::AddAllFonts()
{
wxString path;
if ( !wxGetEnv("WXDFB_FONTPATH", &path) )
path = wxT(wxINSTALL_PREFIX "/share/wx/fonts");
wxStringTokenizer tkn(path, wxPATH_SEP);
while ( tkn.HasMoreTokens() )
{
wxString dir = tkn.GetNextToken();
if ( !wxDir::Exists(dir) )
{
wxLogDebug("font directory %s doesn't exist", dir);
continue;
}
wxArrayString indexFiles;
if ( !wxDir::GetAllFiles(dir, &indexFiles, "FontsIndex") )
continue;
for ( wxArrayString::const_iterator i = indexFiles.begin();
i != indexFiles.end(); ++i )
{
AddFontsFromDir(*i);
}
}
if ( GetBundles().empty() )
{
// We can fall back to the builtin default font if no other fonts are
// defined:
wxLogTrace("font",
_("no fonts found in %s, using builtin font"), path);
AddBundle
(
new wxFontBundle
(
_("Default font"),
BUILTIN_DFB_FONT_FILENAME,
wxEmptyString,
wxEmptyString,
wxEmptyString,
false // IsFixed
)
);
}
}
virtual void ReadValue()
{
wxString s = XmlReadValue(GetNode(), m_PropInfo->Name);
if (s.IsEmpty())
{
m_c[0] = m_c[1] = _T("-1");
}
else
{
wxStringTokenizer tkn(s.BeforeFirst(_T('d')), _T(","));
m_c[0] = tkn.GetNextToken();
m_c[1] = tkn.GetNextToken();
}
m_TextCtrl->SetValue(m_c[m_which]);
}
virtual wxString GetValueAsText(wxTreeItemId ti)
{
PropertyInfo *pi = &(((PETreeData*)m_TreeCtrl->GetItemData(ti))->PropInfo);
wxString s = XmlReadValue(GetNode(), pi->Name);
if (s.IsEmpty())
{
m_c[0] = m_c[1] = _T("-1");
}
else
{
wxStringTokenizer tkn(s.BeforeFirst(_T('d')), _T(","));
m_c[0] = tkn.GetNextToken();
m_c[1] = tkn.GetNextToken();
}
return m_c[m_which];
}
void ManagerFrame::UpdateListCat(int id)
{
wxBusyCursor bcur;
if (id == -1) id = m_curPrj;
wxConfigBase *cfg = wxConfig::Get();
wxString key;
key.Printf("Manager/project_%i/", id);
wxString dirs = cfg->Read(key + "Dirs", wxEmptyString);
wxStringTokenizer tkn(dirs, wxPATH_SEP);
m_catalogs.Clear();
while (tkn.HasMoreTokens())
wxDir::GetAllFiles(tkn.GetNextToken(), &m_catalogs,
"*.po", wxDIR_FILES | wxDIR_DIRS);
m_catalogs.Sort();
m_listCat->Freeze();
m_listCat->ClearAll();
m_listCat->InsertColumn(0, _("Catalog"));
m_listCat->InsertColumn(1, _("Total"));
m_listCat->InsertColumn(2, _("Untrans"));
m_listCat->InsertColumn(3, _("Needs Work"));
m_listCat->InsertColumn(4, _("Bad Tokens"));
m_listCat->InsertColumn(5, _("Last modified"));
// FIXME: this is time-consuming, it should be done in parallel on
// multi-core/SMP systems
for (int i = 0; i < (int)m_catalogs.GetCount(); i++)
AddCatalogToList(m_listCat, i, id, m_catalogs[i]);
m_listCat->SetColumnWidth(0, wxLIST_AUTOSIZE);
m_listCat->SetColumnWidth(1, wxLIST_AUTOSIZE_USEHEADER);
m_listCat->SetColumnWidth(2, wxLIST_AUTOSIZE_USEHEADER);
m_listCat->SetColumnWidth(3, wxLIST_AUTOSIZE_USEHEADER);
m_listCat->SetColumnWidth(4, wxLIST_AUTOSIZE_USEHEADER);
m_listCat->SetColumnWidth(5, wxLIST_AUTOSIZE);
m_listCat->Thaw();
}
void AssDialogueBlockOverride::ParseTags() {
delete_clear(Tags);
wxStringTokenizer tkn(text, "\\", wxTOKEN_STRTOK);
wxString curTag;
if (text.StartsWith("\\")) curTag = "\\";
while (tkn.HasMoreTokens()) {
curTag += tkn.GetNextToken();
// Check for parenthesis matching for \t
while (curTag.Freq('(') > curTag.Freq(')') && tkn.HasMoreTokens()) {
curTag << "\\" << tkn.GetNextToken();
}
Tags.push_back(new AssOverrideTag(curTag));
curTag = "\\";
}
}
void Setup()
{
m_paths = new wxEditableListBox(
XRCCTRL(*this, "tm_update_1", wxWizardPage),
-1, _("Search Paths"));
wxXmlResource::Get()->AttachUnknownControl(_T("search_paths"), m_paths);
m_files = new wxEditableListBox(
XRCCTRL(*this, "tm_update_2", wxWizardPage),
-1, _("Files List"));
wxXmlResource::Get()->AttachUnknownControl(_T("files_list"), m_files);
FitToPage(XRCCTRL(*this, "tm_update_2", wxWizardPage));
// Setup search paths:
wxString dirsStr =
wxConfig::Get()->Read(_T("TM/search_paths"), wxEmptyString);
wxArrayString dirsArray;
wxStringTokenizer tkn(dirsStr, wxPATH_SEP);
while (tkn.HasMoreTokens()) dirsArray.Add(tkn.GetNextToken());
m_paths->SetStrings(dirsArray);
}
static void processPlatformAttribute(wxXmlNode *node)
{
wxString s;
bool isok;
wxXmlNode *c = node->GetChildren();
while (c)
{
isok = false;
if (!c->GetAttribute("platform", &s))
isok = true;
else
{
wxStringTokenizer tkn(s, " |");
while (!isok && tkn.HasMoreTokens())
{
if (tkn.GetNextToken().compare(getPlatformName()) == 0)
isok = true;
}
}
if (isok)
{
processPlatformAttribute(c);
c = c->GetNext();
}
else
{
wxXmlNode *c2 = c->GetNext();
node->RemoveChild(c);
delete c;
c = c2;
}
}
}
// Turns LLL tree into tree of code fragments
programData opcodeify(Node node,
programAux aux=Aux(),
programVerticalAux vaux=verticalAux()) {
std::string symb = "_"+mkUniqueToken();
Metadata m = node.metadata;
// Numbers
if (node.type == TOKEN) {
return pd(aux, nodeToNumeric(node), 1);
}
else if (node.val == "ref" || node.val == "get" || node.val == "set") {
std::string varname = node.args[0].val;
// Determine reference to variable
if (!aux.vars.count(node.args[0].val)) {
aux.vars[node.args[0].val] = utd(aux.nextVarMem);
aux.nextVarMem += 32;
}
Node varNode = tkn(aux.vars[varname], m);
//std::cerr << varname << " " << printSimple(varNode) << "\n";
// Set variable
if (node.val == "set") {
programData sub = opcodeify(node.args[1], aux, vaux);
if (!sub.outs)
err("Value to set variable must have nonzero arity!", m);
// What if we are setting a stack variable?
if (vaux.dupvars.count(node.args[0].val)) {
int h = vaux.height - vaux.dupvars[node.args[0].val];
if (h > 16) err("Too deep for stack variable (max 16)", m);
Node nodelist[] = {
sub.code,
token("SWAP"+unsignedToDecimal(h), m),
token("POP", m)
};
return pd(sub.aux, multiToken(nodelist, 3, m), 0);
}
// Setting a memory variable
else {
Node nodelist[] = {
sub.code,
varNode,
token("MSTORE", m),
};
return pd(sub.aux, multiToken(nodelist, 3, m), 0);
}
}
// Get variable
else if (node.val == "get") {
// Getting a stack variable
if (vaux.dupvars.count(node.args[0].val)) {
int h = vaux.height - vaux.dupvars[node.args[0].val];
if (h > 16) err("Too deep for stack variable (max 16)", m);
return pd(aux, token("DUP"+unsignedToDecimal(h)), 1);
}
// Getting a memory variable
else {
Node nodelist[] =
{ varNode, token("MLOAD", m) };
return pd(aux, multiToken(nodelist, 2, m), 1);
}
}
// Refer variable
else if (node.val == "ref") {
if (vaux.dupvars.count(node.args[0].val))
err("Cannot ref stack variable!", m);
return pd(aux, varNode, 1);
}
}
// Comments do nothing
else if (node.val == "comment") {
return pd(aux, astnode("_", m), 0);
}
// Custom operation sequence
// eg. (ops bytez id msize swap1 msize add 0 swap1 mstore) == alloc
if (node.val == "ops") {
std::vector<Node> subs2;
int depth = 0;
for (unsigned i = 0; i < node.args.size(); i++) {
std::string op = upperCase(node.args[i].val);
if (node.args[i].type == ASTNODE || opinputs(op) == -1) {
programVerticalAux vaux2 = vaux;
vaux2.height = vaux.height - i - 1 + node.args.size();
programData sub = opcodeify(node.args[i], aux, vaux2);
aux = sub.aux;
depth += sub.outs;
subs2.push_back(sub.code);
}
else {
subs2.push_back(token(op, m));
depth += opoutputs(op) - opinputs(op);
}
}
if (depth < 0 || depth > 1) err("Stack depth mismatch", m);
return pd(aux, astnode("_", subs2, m), 0);
}
// Code blocks
if (node.val == "lll" && node.args.size() == 2) {
if (node.args[1].val != "0") aux.allocUsed = true;
std::vector<Node> o;
o.push_back(finalize(opcodeify(node.args[0])));
programData sub = opcodeify(node.args[1], aux, vaux);
Node code = astnode("____CODE", o, m);
Node nodelist[] = {
token("$begincode"+symb+".endcode"+symb, m), token("DUP1", m),
token("$begincode"+symb, m), sub.code, token("CODECOPY", m),
token("$endcode"+symb, m), token("JUMP", m),
token("~begincode"+symb, m), code,
token("~endcode"+symb, m), token("JUMPDEST", m)
};
return pd(sub.aux, multiToken(nodelist, 11, m), 1);
}
// Stack variables
if (node.val == "with") {
programData initial = opcodeify(node.args[1], aux, vaux);
programVerticalAux vaux2 = vaux;
vaux2.dupvars[node.args[0].val] = vaux.height;
vaux2.height += 1;
if (!initial.outs)
err("Initial variable value must have nonzero arity!", m);
programData sub = opcodeify(node.args[2], initial.aux, vaux2);
Node nodelist[] = {
initial.code,
sub.code
};
programData o = pd(sub.aux, multiToken(nodelist, 2, m), sub.outs);
if (sub.outs)
o.code.args.push_back(token("SWAP1", m));
o.code.args.push_back(token("POP", m));
return o;
}
// Seq of multiple statements
if (node.val == "seq") {
std::vector<Node> children;
int lastOut = 0;
for (unsigned i = 0; i < node.args.size(); i++) {
programData sub = opcodeify(node.args[i], aux, vaux);
aux = sub.aux;
if (sub.outs == 1) {
if (i < node.args.size() - 1) sub.code = popwrap(sub.code);
else lastOut = 1;
}
children.push_back(sub.code);
}
return pd(aux, astnode("_", children, m), lastOut);
}
// 2-part conditional (if gets rewritten to unless in rewrites)
else if (node.val == "unless" && node.args.size() == 2) {
programData cond = opcodeify(node.args[0], aux, vaux);
programData action = opcodeify(node.args[1], cond.aux, vaux);
aux = action.aux;
if (!cond.outs) err("Condition of if/unless statement has arity 0", m);
if (action.outs) action.code = popwrap(action.code);
Node nodelist[] = {
cond.code,
token("$endif"+symb, m), token("JUMPI", m),
action.code,
token("~endif"+symb, m), token("JUMPDEST", m)
};
return pd(aux, multiToken(nodelist, 6, m), 0);
}
// 3-part conditional
else if (node.val == "if" && node.args.size() == 3) {
programData ifd = opcodeify(node.args[0], aux, vaux);
programData thend = opcodeify(node.args[1], ifd.aux, vaux);
programData elsed = opcodeify(node.args[2], thend.aux, vaux);
aux = elsed.aux;
if (!ifd.outs)
err("Condition of if/unless statement has arity 0", m);
// Handle cases where one conditional outputs something
// and the other does not
int outs = (thend.outs && elsed.outs) ? 1 : 0;
if (thend.outs > outs) thend.code = popwrap(thend.code);
if (elsed.outs > outs) elsed.code = popwrap(elsed.code);
Node nodelist[] = {
ifd.code,
token("ISZERO", m),
token("$else"+symb, m), token("JUMPI", m),
thend.code,
token("$endif"+symb, m), token("JUMP", m),
token("~else"+symb, m), token("JUMPDEST", m),
elsed.code,
token("~endif"+symb, m), token("JUMPDEST", m)
};
return pd(aux, multiToken(nodelist, 12, m), outs);
}
// While (rewritten to this in rewrites)
else if (node.val == "until") {
programData cond = opcodeify(node.args[0], aux, vaux);
programData action = opcodeify(node.args[1], cond.aux, vaux);
aux = action.aux;
if (!cond.outs)
err("Condition of while/until loop has arity 0", m);
if (action.outs) action.code = popwrap(action.code);
Node nodelist[] = {
token("~beg"+symb, m), token("JUMPDEST", m),
cond.code,
token("$end"+symb, m), token("JUMPI", m),
action.code,
token("$beg"+symb, m), token("JUMP", m),
token("~end"+symb, m), token("JUMPDEST", m),
};
return pd(aux, multiToken(nodelist, 10, m));
}
// Memory allocations
else if (node.val == "alloc") {
programData bytez = opcodeify(node.args[0], aux, vaux);
aux = bytez.aux;
if (!bytez.outs)
err("Alloc input has arity 0", m);
aux.allocUsed = true;
Node nodelist[] = {
bytez.code,
token("MSIZE", m), token("SWAP1", m), token("MSIZE", m),
token("ADD", m),
token("0", m), token("SWAP1", m), token("MSTORE", m)
};
return pd(aux, multiToken(nodelist, 8, m), 1);
}
// All other functions/operators
else {
std::vector<Node> subs2;
int depth = opinputs(upperCase(node.val));
if (depth == -1)
err("Not a function or opcode: "+node.val, m);
if ((int)node.args.size() != depth)
err("Invalid arity for "+node.val, m);
for (int i = node.args.size() - 1; i >= 0; i--) {
programVerticalAux vaux2 = vaux;
vaux2.height = vaux.height - i - 1 + node.args.size();
programData sub = opcodeify(node.args[i], aux, vaux2);
aux = sub.aux;
if (!sub.outs)
err("Input "+unsignedToDecimal(i)+" has arity 0", sub.code.metadata);
subs2.push_back(sub.code);
}
subs2.push_back(token(upperCase(node.val), m));
int outdepth = opoutputs(upperCase(node.val));
return pd(aux, astnode("_", subs2, m), outdepth);
}
}
int wxSizerXmlHandler::GetSizerFlags()
{
const wxString s = GetParamValue(wxS("flag"));
if ( s.empty() )
return 0;
// Parse flags keeping track of invalid combinations. This is somewhat
// redundant with the checks performed in wxSizer subclasses themselves but
// doing it here allows us to give the exact line number at which the
// offending line numbers are given, which is very valuable.
//
// We also can detect invalid flags combinations involving wxALIGN_LEFT and
// wxALIGN_TOP here, while this is impossible at wxSizer level as both of
// these flags have value of 0.
// As the logic is exactly the same in horizontal and vertical
// orientations, use arrays and loops to avoid duplicating the code.
enum Orient
{
Orient_Horz,
Orient_Vert,
Orient_Max
};
const char* const orientName[] = { "horizontal", "vertical" };
// The already seen alignment flag in the given orientation or empty if
// none have been seen yet.
wxString alignFlagIn[] = { wxString(), wxString() };
// Either "wxEXPAND" or "wxGROW" depending on the string used in the input,
// or empty string if none is specified.
wxString expandFlag;
// Either "wxALIGN_CENTRE" or "wxALIGN_CENTER" if either flag was found or
// empty string.
wxString centreFlag;
// Indicates whether we can use alignment in the given orientation at all.
bool alignAllowedIn[] = { true, true };
// Find out the sizer orientation: it is the principal/major size direction
// for the 1D sizers and undefined/invalid for the 2D ones.
Orient orientSizer;
if ( wxBoxSizer* const boxSizer = wxDynamicCast(m_parentSizer, wxBoxSizer) )
{
orientSizer = boxSizer->GetOrientation() == wxHORIZONTAL
? Orient_Horz
: Orient_Vert;
// Alignment can be only used in the transversal/minor direction.
alignAllowedIn[orientSizer] = false;
}
else
{
orientSizer = Orient_Max;
}
int flags = 0;
wxStringTokenizer tkn(s, wxS("| \t\n"), wxTOKEN_STRTOK);
while ( tkn.HasMoreTokens() )
{
const wxString flagName = tkn.GetNextToken();
const int n = m_styleNames.Index(flagName);
if ( n == wxNOT_FOUND )
{
ReportParamError
(
"flag",
wxString::Format("unknown sizer flag \"%s\"", flagName)
);
continue;
}
// Flag description is the string that appears in the error messages,
// the main difference from the flag name is that it can indicate that
// wxALIGN_CENTRE_XXX flag could have been encountered as part of
// wxALIGN_CENTRE which should make the error message more clear as
// seeing references to e.g. wxALIGN_CENTRE_VERTICAL when it's never
// used could be confusing.
wxString flagDesc = wxS('"') + flagName + wxS('"');
int flag = m_styleValues[n];
bool flagSpecifiesAlignIn[] = { false, false };
switch ( flag )
{
case wxALIGN_CENTRE_HORIZONTAL:
case wxALIGN_RIGHT:
flagSpecifiesAlignIn[Orient_Horz] = true;
break;
case wxALIGN_CENTRE_VERTICAL:
case wxALIGN_BOTTOM:
flagSpecifiesAlignIn[Orient_Vert] = true;
break;
case wxEXPAND:
expandFlag = flagName;
break;
case wxALIGN_CENTRE:
// wxALIGN_CENTRE is a combination of wxALIGN_CENTRE_HORIZONTAL
// and wxALIGN_CENTRE_VERTICAL but we also handle it as just
// one of those flags if alignment in the other direction is
// not allowed for both compatibility and convenience reasons.
switch ( orientSizer )
{
case Orient_Horz:
flagSpecifiesAlignIn[Orient_Vert] = true;
flagDesc.Printf
(
"\"wxALIGN_CENTRE_VERTICAL\" (as part of %s)",
flagName
);
flag = wxALIGN_CENTRE_VERTICAL;
break;
case Orient_Vert:
flagSpecifiesAlignIn[Orient_Horz] = true;
flagDesc.Printf
(
"\"wxALIGN_CENTRE_HORIZONTAL\" (as part of %s)",
flagName
);
flag = wxALIGN_CENTRE_HORIZONTAL;
break;
case Orient_Max:
// For 2D sizers we need to deal with this flag at the
// end, so just remember that we had it for now.
centreFlag = flagName;
flag = 0;
break;
}
break;
case 0:
// This is a special case: both wxALIGN_LEFT and wxALIGN_TOP
// have value of 0, so we need to examine the name of the flag
// and not just its value.
if ( flagName == wxS("wxALIGN_LEFT") )
flagSpecifiesAlignIn[Orient_Horz] = true;
else if ( flagName == wxS("wxALIGN_TOP") )
flagSpecifiesAlignIn[Orient_Vert] = true;
break;
}
for ( int orient = 0; orient < Orient_Max; orient++ )
{
if ( !flagSpecifiesAlignIn[orient] )
continue;
if ( !alignAllowedIn[orient] )
{
ReportParamError
(
"flag",
wxString::Format
(
"%s alignment flag %s has no effect inside "
"a %s box sizer, remove it and consider inserting "
"a spacer instead",
orientName[orient],
flagDesc,
orientName[orient]
)
);
// Notice that we take care to not add this invalid flag to the
// flags we will actually use with wxSizer: they would just
// trigger an assert there which wouldn't be very useful as
// we've already given an error about this.
flag = 0;
}
else if ( alignFlagIn[orient].empty() )
{
alignFlagIn[orient] = flagDesc;
}
else
{
ReportParamError
(
"flag",
wxString::Format
(
"both %s and %s specify %s alignment "
"and can't be used together",
alignFlagIn[orient],
flagDesc,
orientName[orient]
)
);
flag = 0;
}
}
flags |= flag;
}
// Now that we know all the alignment flags we can interpret wxALIGN_CENTRE
// for the 2D sizers ("centreFlag" is only set in the 2D case).
if ( !centreFlag.empty() )
{
if ( !expandFlag.empty() )
{
ReportParamError
(
"flag",
wxString::Format
(
"\"%s\" has no effect when combined with \"%s\"",
centreFlag,
expandFlag
)
);
}
else // !wxEXPAND
{
int flagsCentre = 0;
if ( alignFlagIn[Orient_Horz].empty() )
flagsCentre |= wxALIGN_CENTRE_HORIZONTAL;
if ( alignFlagIn[Orient_Vert].empty() )
flagsCentre |= wxALIGN_CENTRE_VERTICAL;
if ( !flagsCentre )
{
ReportParamError
(
"flag",
wxString::Format
(
"\"%s\" flag has no effect when combined "
"with both %s and %s horizontal and "
"vertical alignment flags",
centreFlag,
alignFlagIn[Orient_Horz],
alignFlagIn[Orient_Vert]
)
);
}
flags |= flagsCentre;
}
}
// Finally check that the alignment flags are compatible with wxEXPAND.
if ( !expandFlag.empty() )
{
if ( orientSizer != Orient_Max )
{
const Orient orientOther = orientSizer == Orient_Horz
? Orient_Vert
: Orient_Horz;
if ( !alignFlagIn[orientOther].empty() )
{
ReportParamError
(
"flag",
wxString::Format
(
"\"%s\" is incompatible with %s alignment flag "
"\"%s\" in a %s box sizer",
expandFlag,
orientName[orientOther],
alignFlagIn[orientOther],
orientName[orientSizer]
)
);
// Just as with the alignment flags above, ignore wxEXPAND
// completely to avoid asserts from wxSizer code.
flags &= ~wxEXPAND;
}
}
else // 2D sizer
{
if ( !alignFlagIn[Orient_Horz].empty() &&
!alignFlagIn[Orient_Vert].empty() )
{
ReportParamError
(
"flag",
wxString::Format
(
"\"%s\" flag has no effect when combined "
"with both %s and %s horizontal and "
"vertical alignment flags",
expandFlag,
alignFlagIn[Orient_Horz],
alignFlagIn[Orient_Vert]
)
);
flags &= ~wxEXPAND;
}
}
}
return flags;
}
bool CMP_LIBRARY::Load( wxString& aErrorMsg )
{
FILE* file;
char* line;
LIB_COMPONENT* libEntry;
wxString msg;
if( fileName.GetFullPath().IsEmpty() )
{
aErrorMsg = _( "The component library file name is not set." );
return false;
}
file = wxFopen( fileName.GetFullPath(), wxT( "rt" ) );
if( file == NULL )
{
aErrorMsg = _( "The file could not be opened." );
return false;
}
FILE_LINE_READER reader( file, fileName.GetFullPath() );
if( !reader.ReadLine() )
{
aErrorMsg = _( "The file is empty!" );
return false;
}
/* There is no header if this is a symbol library. */
if( type == LIBRARY_TYPE_EESCHEMA )
{
wxString tmp;
line = reader.Line();
header = FROM_UTF8( line );
wxStringTokenizer tkn( header );
/*
* The file header (first line) in library versions 2.0 and lower
* apparently started with EESchema-LIB. Sometime after 2.0, it
* was changed to EESchema-LIBRARY. Therefore, the test for
* EESchema-LIB will work in both cases. Don't change this unless
* backwards compatibility is no longer required.
*/
if( !tkn.HasMoreTokens()
|| !tkn.GetNextToken().Upper().StartsWith(wxT( "EESCHEMA-LIB" ) ) )
{
aErrorMsg = _( "The file is NOT an Eeschema library!" );
return false;
}
if( !tkn.HasMoreTokens() )
{
aErrorMsg = _( "The file header is missing version and time stamp information." );
return false;
}
if( tkn.GetNextToken() != wxT( "Version" ) || !tkn.HasMoreTokens() )
{
aErrorMsg = wxT( "The file header version information is invalid." );
return false;
}
long major, minor;
wxStringTokenizer vers( tkn.GetNextToken(), wxT( "." ) );
if( !vers.HasMoreTokens() || !vers.GetNextToken().ToLong( &major )
|| major < 1L || !vers.HasMoreTokens()
|| !vers.GetNextToken().ToLong( & minor ) || minor < 0L
|| minor > 99 )
{
#if 0 // Note for developers:
// Not sure this warning is very useful: old designs *must* be always loadable
wxLogWarning( wxT( "The component library <%s> header version \
number is invalid.\n\nIn future versions of Eeschema this library may not \
load correctly. To resolve this problem open the library in the library \
editor and save it. If this library is the project cache library, save \
the current schematic." ),
GetChars( GetName() ) );
#endif
}
void NodeInfo::Read(const wxString& filename, wxPathList& list)
{
wxString tp;
wxString nd, cht;
bool ab = FALSE;
long icn = -1;
NodeClass.Empty();
wxString path = list.FindValidPath(filename);
if (path.IsEmpty()) return;
wxTextFile tf;
tf.Open(path);
if (!tf.IsOpened()) return;
for (size_t i = 0; i < tf.GetLineCount(); i++)
{
if (tf[i].IsEmpty() || tf[i][0u] == _T('#')) continue;
wxStringTokenizer tkn(tf[i], _T(' '));
wxString s = tkn.GetNextToken();
if (s == _T("node"))
nd = tkn.GetNextToken();
else if (s == _T("childtype"))
cht = tkn.GetNextToken();
else if (s == _T("icon"))
tkn.GetNextToken().ToLong(&icn);
else if (s == _T("derived"))
{
if (tkn.GetNextToken() == _T("from"))
{
s = tkn.GetNextToken();
DerivedFrom.Add(s);
Read(s + _T(".df"), list);
}
}
else if (s == _T("abstract"))
ab = true;
else if (s == _T("type"))
{
tp = tkn.GetNextToken();
}
else if (s == _T("var"))
{
PropertyInfo pi;
pi.Name = tkn.GetNextToken();
tkn.GetNextToken();
pi.Type = tkn.GetNextToken();
if (tkn.HasMoreTokens()) pi.MoreInfo = tkn.GetNextToken();
bool fnd = FALSE;
for (size_t j = 0; j < Props.GetCount(); j++)
{
if (Props[j].Name == pi.Name)
{
if (Props[j].Type == pi.Type && pi.Type == _T("flags"))
Props[j].MoreInfo << _T(',') << pi.MoreInfo;
else
Props[j] = pi;
fnd = TRUE;
}
}
if (!fnd) Props.Add(pi);
}
}
if (!nd.IsEmpty()) NodeClass = nd;
if (!cht.IsEmpty()) ChildType = cht;
if (!!tp) Type = tp;
if (icn != -1) Icon = icn;
Abstract = ab;
}
void PreferencesDialog::TransferTo(wxConfigBase *cfg)
{
XRCCTRL(*this, "user_name", wxTextCtrl)->SetValue(
cfg->Read(_T("translator_name"), wxEmptyString));
XRCCTRL(*this, "user_email", wxTextCtrl)->SetValue(
cfg->Read(_T("translator_email"), wxEmptyString));
XRCCTRL(*this, "compile_mo", wxCheckBox)->SetValue(
cfg->Read(_T("compile_mo"), (long)true));
XRCCTRL(*this, "show_summary", wxCheckBox)->SetValue(
cfg->Read(_T("show_summary"), true));
XRCCTRL(*this, "manager_startup", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("manager_startup"), (long)false));
XRCCTRL(*this, "focus_to_text", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("focus_to_text"), (long)false));
XRCCTRL(*this, "comment_window_editable", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("comment_window_editable"), (long)false));
XRCCTRL(*this, "keep_crlf", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("keep_crlf"), true));
#ifdef USE_SPELLCHECKING
XRCCTRL(*this, "enable_spellchecking", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("enable_spellchecking"), true));
#endif
XRCCTRL(*this, "use_font_list", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("custom_font_list_use"), (long)false));
XRCCTRL(*this, "use_font_text", wxCheckBox)->SetValue(
(bool)cfg->Read(_T("custom_font_text_use"), (long)false));
XRCCTRL(*this, "font_list", wxFontPickerCtrl)->SetSelectedFont(
wxFont(cfg->Read(_T("custom_font_list_name"), wxEmptyString)));
XRCCTRL(*this, "font_text", wxFontPickerCtrl)->SetSelectedFont(
wxFont(cfg->Read(_T("custom_font_text_name"), wxEmptyString)));
wxString format = cfg->Read(_T("crlf_format"), _T("unix"));
int sel;
if (format == _T("win")) sel = 1;
else /* _T("unix") or obsolete settings */ sel = 0;
XRCCTRL(*this, "crlf_format", wxChoice)->SetSelection(sel);
m_parsers.Read(cfg);
wxListBox *list = XRCCTRL(*this, "parsers_list", wxListBox);
for (unsigned i = 0; i < m_parsers.GetCount(); i++)
list->Append(m_parsers[i].Name);
if (m_parsers.GetCount() == 0)
{
XRCCTRL(*this, "parser_edit", wxButton)->Enable(false);
XRCCTRL(*this, "parser_delete", wxButton)->Enable(false);
}
else
list->SetSelection(0);
#ifdef USE_TRANSMEM
wxStringTokenizer tkn(cfg->Read(_T("TM/languages"), wxEmptyString), _T(":"));
wxArrayString langs;
while (tkn.HasMoreTokens()) langs.Add(tkn.GetNextToken());
XRCCTRL(*this, "tm_langs", wxEditableListBox)->SetStrings(langs);
XRCCTRL(*this, "tm_omits", wxSpinCtrl)->SetValue(
cfg->Read(_T("TM/max_omitted"), 2));
XRCCTRL(*this, "tm_delta", wxSpinCtrl)->SetValue(
cfg->Read(_T("TM/max_delta"), 2));
XRCCTRL(*this, "tm_automatic", wxCheckBox)->SetValue(
cfg->Read(_T("use_tm_when_updating"), true));
#endif
#ifdef USE_SPARKLE
XRCCTRL(*this, "auto_updates", wxCheckBox)->SetValue(
(bool)UserDefaults_GetBoolValue("SUEnableAutomaticChecks"));
#endif // USE_SPARKLE
#ifdef __WXMSW__
XRCCTRL(*this, "auto_updates", wxCheckBox)->SetValue(
(bool)win_sparkle_get_automatic_check_for_updates());
#endif
}
