TFastIni::TFastIni(TStringList *SL) :
m_LastSectionIndex(-1)
{
m_Sections = new TList();
LoadFromString(SL);
}
bool cPrefabPiecePool::LoadFromString(const AString & a_Contents, const AString & a_FileName, bool a_LogWarnings)
{
// If the contents start with GZip signature, ungzip and retry:
if (a_Contents.substr(0, 3) == "\x1f\x8b\x08")
{
AString Uncompressed;
auto res = UncompressStringGZIP(a_Contents.data(), a_Contents.size(), Uncompressed);
if (res == Z_OK)
{
return LoadFromString(Uncompressed, a_FileName, a_LogWarnings);
}
else
{
CONDWARNING(a_LogWarnings, "Failed to decompress Gzip data in file %s: %d", a_FileName.c_str(), res);
return false;
}
}
// Search the first 8 KiB of the file for the format auto-detection string:
auto Header = a_Contents.substr(0, 8192);
if (Header.find("CubesetFormatVersion =") != AString::npos)
{
return LoadFromCubeset(a_Contents, a_FileName, a_LogWarnings);
}
CONDWARNING(a_LogWarnings, "Cannot load prefabs from file %s, unknown file format", a_FileName.c_str());
return false;
}
BOOL CReportEntityPicture::FromString( const CString& str )
/* ============================================================
Function : CReportEntityPicture::FromString
Description : Sets the data of the object from "str".
Access : Public
Return : BOOL - "TRUE" if the string
represents an object
of this type.
Parameters : const CString& str - String to parse
Usage : Call to load objects from a file.
============================================================*/
{
BOOL result = FALSE;
CString data( str );
if( LoadFromString( data ) )
{
CTokenizer tok( data );
double borderthickness;
unsigned int borderstyle;
unsigned int bordercolor;
CString filename;
int count = 0;
tok.GetAt( count++, borderthickness );
int aaa;
tok.GetAt( count++, aaa );
borderstyle=aaa;
tok.GetAt( count++, aaa );
bordercolor=aaa;
tok.GetAt( count++, filename );
int bt = CUnitConversion::InchesToPixels( borderthickness );
SetBorderThickness( bt );
SetBorderStyle( borderstyle );
SetBorderColor( bordercolor );
UnmakeSaveString( filename );
SetFilename( filename );
int left = CUnitConversion::InchesToPixels( GetLeft() );
int right = CUnitConversion::InchesToPixels( GetRight() );
int top = CUnitConversion::InchesToPixels( GetTop() );
int bottom = CUnitConversion::InchesToPixels( GetBottom() );
CRect rect( left, top, right, bottom );
SetRect( rect );
result = TRUE;
}
return result;
}
Image GetImage(PasteClip& clip)
{
GuiLock __;
Image m;
if(Accept<Image>(clip)) {
LoadFromString(m, ~clip);
if(!m.IsEmpty())
return m;
}
if(clip.Accept("dib")) {
String data = ~clip;
if((unsigned)data.GetCount() < sizeof(BITMAPINFO)) return Null;
BITMAPINFO *lpBI = (BITMAPINFO *)~data;
BITMAPINFOHEADER& hdr = lpBI->bmiHeader;
byte *bits = (byte *)lpBI + hdr.biSize;
if(hdr.biBitCount <= 8)
bits += (hdr.biClrUsed ? hdr.biClrUsed : 1 << hdr.biBitCount) * sizeof(RGBQUAD);
if(hdr.biBitCount >= 16 || hdr.biBitCount == 32) {
if(hdr.biCompression == 3)
bits += 12;
if(hdr.biClrUsed != 0)
bits += hdr.biClrUsed * sizeof(RGBQUAD);
}
int h = abs((int)hdr.biHeight);
ImageDraw iw(hdr.biWidth, h);
::StretchDIBits(iw.GetHandle(),
0, 0, hdr.biWidth, h,
0, 0, hdr.biWidth, h,
bits, lpBI, DIB_RGB_COLORS, SRCCOPY);
return iw;
}
return Null;
}
void Shader::LoadFromFile(const ShaderType type, const std::string fname) {
std::ifstream fp;
fp.open(fname, std::ios_base::in);
if (fp.is_open()) {
std::string buffer(std::istreambuf_iterator<char>(fp), (std::istreambuf_iterator<char>()));
LoadFromString(type, buffer);
}
}
void LuaData::Register()
{
if( !m_bWasSet )
return;
LoadFromString( m_sSerializedData, m_bSandboxed );
m_sSerializedData.erase( m_sSerializedData.begin(), m_sSerializedData.end() );
}
bool
NOAAStore::LoadFromProfile()
{
const TCHAR *stations = Profile::Get(szProfileWeatherStations);
if (stations == NULL)
return false;
return LoadFromString(stations);
}
bool
NOAAStore::LoadFromProfile()
{
const char *stations = Profile::Get(ProfileKeys::WeatherStations);
if (stations == NULL)
return false;
return LoadFromString(stations);
}
bool INI::LoadFromFile(std::string filename)
{
std::ifstream file(filename, std::ios::in);
if (!file) return false;
std::string data((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
file.close();
LoadFromString(data);
return true;
}
std::weak_ptr<Shader> Shader::CreateFromString(const std::string name,
std::list<std::pair<Shader::ShaderType, std::string>> source_code) {
auto s = std::make_shared<Shader>();
for (auto pair : source_code) {
s->LoadFromString(pair.first, pair.second);
}
s->Build();
ShaderMap::Set(name, s);
return s;
}
bool cPrefabPiecePool::LoadFromFile(const AString & a_FileName, bool a_LogWarnings)
{
// Read the file into a string buffer, load from string:
auto contents = cFile::ReadWholeFile(a_FileName);
if (contents.empty())
{
CONDWARNING(a_LogWarnings, "Cannot read data from file %s", a_FileName.c_str());
return false;
}
return LoadFromString(contents, a_FileName, a_LogWarnings);
}
// This code reads up the file, discards the bookends, and saves only the gibberish itself.
bool OTASCIIArmor::LoadFrom_ifstream(std::ifstream & fin)
{
std::stringstream buffer;
buffer << fin.rdbuf();
std::string contents(buffer.str());
OTString theString;
theString.Set(contents.c_str());
return LoadFromString(theString);
}
TFastIni::TFastIni(AnsiString FN) :
m_LastSectionIndex(-1)
{
m_Sections = new TList();
TStringList *SL = new TStringList();
if (FileExists(FN)){
SL->LoadFromFile(FN);
}
LoadFromString(SL);
delete SL;
}
void GLSLShader::LoadFromFile(GLenum whichShader, const string& filename) {
ifstream fp;
fp.open(filename.c_str(), ios_base::in);
if (fp) {
string line, buffer;
while (getline(fp, line)) {
buffer.append(line);
buffer.append("\r\n");
}
LoadFromString(whichShader, buffer);
}
else {
cerr << "Error loading shader: " << filename << endl;
}
}
void GLSLShader::LoadFromFile(GLenum whichShader, const string& filename){
ifstream fp;
fp.open(filename.c_str(), ios_base::in);
if(fp) {
/*string line, buffer;
while(getline(fp, line)) {
buffer.append(line);
buffer.append("\r\n");
} */
string buffer(std::istreambuf_iterator<char>(fp), (std::istreambuf_iterator<char>()));
//copy to source
LoadFromString(whichShader, buffer);
} else {
cerr<<"Error loading shader: "<<filename<<endl;
}
}
void TextBanner::LoadFromSong( const Song* pSong )
{
Init();
CString sDisplayTitle = pSong ? pSong->GetDisplayMainTitle() : CString("");
CString sTranslitTitle = pSong ? pSong->GetTranslitMainTitle() : CString("");
CString sDisplaySubTitle = pSong ? pSong->GetDisplaySubTitle() : CString("");
CString sTranslitSubTitle = pSong ? pSong->GetTranslitSubTitle() : CString("");
CString sDisplayArtist = pSong ? (CString)ARTIST_PREPEND_STRING + pSong->GetDisplayArtist() : CString("");
CString sTranslitArtist = pSong ? (CString)ARTIST_PREPEND_STRING + pSong->GetTranslitArtist() : CString("");
LoadFromString(
sDisplayTitle, sTranslitTitle,
sDisplaySubTitle, sTranslitSubTitle,
sDisplayArtist, sTranslitArtist );
}
void Shader::LoadFromFile(GLenum whichShader, const std::string& filename)
{
ifstream fp(filename, ifstream::in);
if (fp.is_open())
{
string line, buffer;
while (getline(fp, line))
{
buffer.append(line);
buffer.append("\r\n");
}
//copy to source
LoadFromString(whichShader, buffer);
}
else
{
cerr << "Error loading shader: " << filename << endl;
}
}
BOOL CXmlManager::LoadFromFile( LPCTSTR szfilename )
{
BOOL ret = FALSE;
CAtlFile file;
if(S_OK == file.Create(szfilename, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING) )
{
int nsize = ::GetFileSize(file, NULL);
char* szbuf = new char[nsize + 1];
if(szbuf)
{
if(S_OK == file.Read(szbuf, nsize))
{
szbuf[nsize] = 0;
ret = LoadFromString(szbuf, nsize);
}
delete [] szbuf;
}
}
return ret;
}
// This code reads up the file, discards the bookends, and saves only the gibberish itself.
bool OTASCIIArmor::LoadFromFile(const OTString & foldername, const OTString & filename)
{
/*
std::ifstream fin(filename.Get(), std::ios::binary);
if (!fin.is_open())
{
OTLog::vError("Error opening file in OTASCIIArmor::LoadFromFile: %s\n", filename.Get());
return false;
}
return LoadFromifstream(fin);
*/
OT_ASSERT(foldername.Exists());
OT_ASSERT(filename.Exists());
// --------------------------------------------------------------------
if (false == OTDB::Exists(foldername.Get(), filename.Get()))
{
OTLog::vError("OTASCIIArmor::LoadFromFile: File does not exist: %s%s%s\n",
foldername.Get(), OTLog::PathSeparator(), filename.Get());
return false;
}
// --------------------------------------------------------------------
//
OTString strFileContents(OTDB::QueryPlainString(foldername.Get(), filename.Get())); // <=== LOADING FROM DATA STORE.
if (strFileContents.GetLength() < 2)
{
OTLog::vError("OTASCIIArmor::LoadFromFile: Error reading file: %s%s%s\n",
foldername.Get(), OTLog::PathSeparator(), filename.Get());
return false;
}
// --------------------------------------------------------------------
return LoadFromString(strFileContents);
}
bool Lua::RunExpression( const CString &str )
{
if( setjmp(jbuf) )
RageException::Throw( "Error running \"%s\": %s", str.c_str(), jbuf_error.c_str() );
lua_State *L = lua_open();
ASSERT( L );
lua_atpanic( L, LuaPanic );
luaopen_base( L );
luaopen_math( L );
luaopen_string( L );
lua_settop(L, 0); // luaopen_* pushes stuff onto the stack that we don't need
Lua::RegisterFunctions( L );
LoadFromString( L, "return " + str );
ASSERT_M( lua_gettop(L) == 1, ssprintf("%i", lua_gettop(L)) );
int ret = lua_pcall(L, 0, 1, 0);
if( ret )
{
CString err;
Lua::PopStack( L, err );
RageException::Throw( "Runtime error running \"%s\": %s", str.c_str(), err.c_str() );
}
ASSERT_M( lua_gettop(L) == 1, ssprintf("%i", lua_gettop(L)) );
/* Don't accept a function as a return value; if you really want to use a function
* as a boolean, convert it before returning. */
if( lua_isfunction( L, -1 ) )
RageException::Throw( "Error running \"%s\": result is a function; did you forget \"()\"?", str.c_str() );
bool result = !!lua_toboolean( L, -1 );
lua_pop( L, -1 );
lua_close( L );
return result;
}
void Shader::LoadFromFile(Type type, std::string filename)
{
std::string src;
std::ifstream File(filename, std::ifstream::in);
if (!File.is_open())
{
std::cerr <<"Shader Source File does not exist: " <<filename <<"\n";
return;
}
while (!File.eof())
{
char buf[1024];
File.getline(buf, sizeof(buf));
src +=buf + std::string("\n");
}
LoadFromString(type, src);
}
/**
* parse primitve. this method parses the values, that are stored inside the Xml-document
* handled by the XmlParser \p p.
* @param p the parser holding the xml document
* @return the Value contained in the xml document
*/
Value XmlRpcParser::ParsePrimitive(XmlParser& p) {
Value v,vv;
if(p.IsText()) {
return Value(p.ReadText());
}
for(int i=0;i<7;i++) {
if(p.Tag(primitives[i])) {
switch(i) {
case 0: //string
v=Value(p.ReadText());
break;
case 1: //int
case 2: //i4
v = Value(atoi(p.ReadText()));
break;
case 3: //boolean
v = Value((bool)atoi(p.ReadText()));
break;
case 4: //double
v = Value(atof(p.ReadText()));
break;
case 5: //dateTime.iso8601
p.ReadTextE();
v=Value(Date(1970,1,1));
break;
case 6: //base64
LoadFromString(vv, p.ReadText());
v = Value(vv);
break;
default:
throw Exc("unexpected Error");
break;
}
p.PassEnd();
return Value(v);
}
}
throw Exc("unknown primitive");
}
BOOL CDiagramPort::FromString(const CString& str) {
BOOL result = FALSE;
CString data(str);
if (LoadFromString(data)) {
CTokenizer tok(data);
int lSerialPort0;
int lSerialPort1;
int lUSB;
int lI2C;
int lSPI;
int lEthernet;
int count = 0;
tok.GetAt(count++, lSerialPort0);
tok.GetAt(count++, lSerialPort1);
tok.GetAt(count++, lUSB);
tok.GetAt(count++, lI2C);
tok.GetAt(count++, lSPI);
tok.GetAt(count++, lEthernet);
this->mSerialPort0 = lSerialPort0;
this->mSerialPort1 = lSerialPort1;
this->mUSB = lUSB;
this->mI2C = lI2C;
this->mSPI = lSPI;
this->mEthernet = lEthernet;
result = TRUE;
}
return result;
}
// This code reads up the file, discards the bookends, and saves only the gibberish itself.
bool OTASCIIArmor::LoadFromFile(const OTString & foldername, const OTString & filename)
{
OT_ASSERT(foldername.Exists());
OT_ASSERT(filename.Exists());
// --------------------------------------------------------------------
if (false == OTDB::Exists(foldername.Get(), filename.Get()))
{
OTLog::vError("OTASCIIArmor::LoadFromFile: File does not exist: %s%s%s\n",
foldername.Get(), OTLog::PathSeparator(), filename.Get());
return false;
}
// --------------------------------------------------------------------
OTString strFileContents(OTDB::QueryPlainString(foldername.Get(), filename.Get())); // <=== LOADING FROM DATA STORE.
if (strFileContents.GetLength() < 2)
{
OTLog::vError("OTASCIIArmor::LoadFromFile: Error reading file: %s%s%s\n",
foldername.Get(), OTLog::PathSeparator(), filename.Get());
return false;
}
// --------------------------------------------------------------------
return LoadFromString(strFileContents);
}
BOOL CSkin::LoadFromResource(HINSTANCE hInstance, UINT nResourceID)
{
HMODULE hModule = hInstance != NULL ? (HMODULE)hInstance : GetModuleHandle( NULL );
HRSRC hRes = FindResource( hModule, MAKEINTRESOURCE( nResourceID ), MAKEINTRESOURCE( 23 ) );
if ( hRes == NULL ) return FALSE;
CString strBody;
DWORD nSize = SizeofResource( hModule, hRes );
HGLOBAL hMemory = ::LoadResource( hModule, hRes );
LPTSTR pszOutput = strBody.GetBuffer( nSize + 1 );
LPCSTR pszInput = (LPCSTR)LockResource( hMemory );
while ( nSize-- ) *pszOutput++ = *pszInput++;
*pszOutput++ = 0;
strBody.ReleaseBuffer();
CString strPath;
strPath.Format( _T("%lu$"), (DWORD)hModule );
return LoadFromString( strBody, strPath );
}
// This code reads up the file, discards the bookends, and saves only the
// gibberish itself.
bool OTASCIIArmor::LoadFromFile(const String& foldername,
const String& filename)
{
OT_ASSERT(foldername.Exists());
OT_ASSERT(filename.Exists());
if (!OTDB::Exists(foldername.Get(), filename.Get())) {
otErr << "OTASCIIArmor::LoadFromFile: File does not exist: "
<< foldername << "" << Log::PathSeparator() << "" << filename
<< "\n";
return false;
}
String strFileContents(OTDB::QueryPlainString(
foldername.Get(), filename.Get())); // <=== LOADING FROM DATA STORE.
if (strFileContents.GetLength() < 2) {
otErr << "OTASCIIArmor::LoadFromFile: Error reading file: "
<< foldername << Log::PathSeparator() << filename << "\n";
return false;
}
return LoadFromString(strFileContents);
}
void FormEdit::UpdateChildCount(int count)
{
for (int i = 0; i < _Ctrls.GetCount(); ++i)
_CtrlContainer.RemoveChild(&_Ctrls[i]);
_Ctrls.Clear();
_ItemList.Clear();
_Temporaries.Clear();
if (!_View.IsLayout())
{
UpdateItemList();
return;
}
// if (_ViewMode == VIEW_MODE_WIREFRAME)
// return;
for (int i = 0; i < count; ++i)
{
if (!_View.GetObject(i))
continue;
String type = (*_View.GetObjects())[i].Get("Type");
Font font = _View.GetFont();
int h = _View.ZoomY((*_View.GetObjects())[i].GetNumber("Font.Height"));
if (h != 0) font.Height(h);
if (font.GetHeight() == 0) font.Height(StdFont().GetHeight());
_ItemList.AddRow(type, (*_View.GetObjects())[i].Get("Variable"));
if ((*_View.GetObjects())[i].GetBool("OutlineDraw", false)
&& _ViewMode != VIEW_MODE_AS_IS)
{
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( _Ctrls.Create<StaticRect>() );
}
else if (type == "Button")
{
Button* b = &_Ctrls.Create<Button>();
b->SetFont(font);
if (_ViewMode == VIEW_MODE_AS_IS)
b->SetLabel((*_View.GetObjects())[i].Get("Label"));
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
else if (type == "DropDate")
{
DropDate *b = &_Ctrls.Create<DropDate>();
b->SetFont(font);
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
else if (type == "GridCtrl")
{
GridCtrl *b = &_Ctrls.Create<GridCtrl>();
// b->SetFont(font); TODO
#ifdef PLATFORM_WIN32
b->Chameleon();
#endif
String src = (*_View.GetObjects())[i].Get("Grid.Columns");
ReplaceString(src, ";", "\r\n");
StringStream s;
s.Open(src);
IniFile f;
f.Load(s);
Vector<String> names = f.EnumNames("Columns");
for (int j = 0; j < names.GetCount(); ++j)
{
int n = ScanInt(names[j]);
Vector<String> values = f.GetArray("Columns", names[j]);
if (values.GetCount() != 3)
continue;
if (values[1] == "Left") b->AddColumn(values[0]).HeaderAlignCenterLeft();
else if (values[1] == "Right") b->AddColumn(values[0]).HeaderAlignCenterRight();
else b->AddColumn(values[0]).HeaderAlignCenter();
}
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
else if (type == "EditField")
{
EditField *b = &_Ctrls.Create<EditField>();
b->SetFont(font);
if (_ViewMode == VIEW_MODE_AS_IS)
b->SetText((*_View.GetObjects())[i].Get("DefaultData"));
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
else if (type == "EditInt")
{
EditInt *b = &_Ctrls.Create<EditInt>();
b->SetFont(font);
if (_ViewMode == VIEW_MODE_AS_IS)
b->SetText((*_View.GetObjects())[i].Get("DefaultData"));
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
else if (type == "ProgressBar")
{
ProgressIndicator *b = &_Ctrls.Create<ProgressIndicator>();
b->Set(0, 100);
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
else if (type == "TabCtrl")
{
TabCtrl* e = &_Ctrls.Create<TabCtrl>();
TabCtrl::Style& style = e->StyleDefault().Write();
style.font = font;
style.tabheight = font.GetHeight() + VertLayoutZoom(10);
e->SetStyle(style);
String src = (*_View.GetObjects())[i].Get("Tab.Content");
ReplaceString(src, ";", "\r\n");
StringStream s;
s.Open(src);
IniFile f;
f.Load(s);
Vector<String> names = f.EnumNames("Tabs");
VectorMap<int, Vector<String> > cache;
int tabCount = 0;
for (int j = 0; j < names.GetCount(); ++j)
{
int n = ScanInt(names[j]);
if (AsString(n) != names[j])
continue;
Vector<String> values = f.GetArray("Tabs", names[j]);
if (values.GetCount() != 3)
continue;
Container *cont = &_Temporaries.Create<Container>();
Form *f = &_Temporaries.Create<Form>();
if (values[0] != t_("Current form"))
{
if (!f->Load(GetFileDirectory(_File) + "\\" + values[0]))
continue;
}
else
{
int lay = _View.HasLayout(values[1]);
if (lay < 0)
continue;
f->GetLayouts().Add() <<= _View.GetLayouts()[lay];
}
if (!f->Layout(values[1], font))
continue;
cont->Set(*f, f->GetSize());
cont->SizePos();
e->Add(*cont, values[2]);
tabCount++;
}
int activeTab = -1;
if (tabCount)
{
activeTab = (*_View.GetObjects())[i].GetNumber("Tab.Active", 0, 0);
if (activeTab >= tabCount)
{
activeTab = tabCount - 1;
e->Set(activeTab);
}
e->Set(activeTab);
}
(*_View.GetObjects())[i].SetNumber("Tab.Active", activeTab);
(*_View.GetObjects())[i].SetNumber("Tab.Count", tabCount);
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( e->NoWantFocus() );
}
else if (type == "Form")
{
Form f;
String path = (*_View.GetObjects())[i].Get("Form.Path");
(*_View.GetObjects())[i].Get("Form.PathType") == "Relative"
? f.Load(::GetFileDirectory(_File) + "\\" + path)
: f.Load(path);
f.Layout((*_View.GetObjects())[i].Get("Form.Layout"), font);
ImageDraw w(f.GetSize());
f.DrawCtrl(w);
ImageBuffer buf(w);
StaticImage *s = &_Ctrls.Create<StaticImage>();
s->SetImage(buf);
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.AddChild( s );
}
else
{
Label *b = &_Ctrls.Create<Label>();
b->SetFont(font);
Color fontColor = DefaultInk();
LoadFromString(fontColor, Decode64((*_View.GetObjects())[i].Get("Font.Color",
StoreAsString(fontColor))));
b->SetInk(fontColor);
String align = (*_View.GetObjects())[i].Get("Text.Align");
if (align == "Center") b->SetAlign(ALIGN_CENTER);
if (align == "Right") b->SetAlign(ALIGN_RIGHT);
if (align == "Left") b->SetAlign(ALIGN_LEFT);
if (_ViewMode == VIEW_MODE_AS_IS)
b->SetLabel((*_View.GetObjects())[i].Get("Label"));
if (_ViewMode != VIEW_MODE_WIREFRAME)
_CtrlContainer.Add( b->NoWantFocus() );
}
String frame = (*_View.GetObjects())[i].Get("Frame");
Ctrl* c = NULL;
if (_Ctrls.GetCount())
c = &_Ctrls[_Ctrls.GetCount() - 1];
if (c)
{
if (frame == "Null frame") c->SetFrame(NullFrame());
if (frame == "Field frame") c->SetFrame(FieldFrame());
if (frame == "Inset frame") c->SetFrame(InsetFrame());
if (frame == "Outset frame") c->SetFrame(OutsetFrame());
if (frame == "Thin inset frame") c->SetFrame(ThinInsetFrame());
if (frame == "Thin outset frame") c->SetFrame(ThinOutsetFrame());
if (frame == "Black frame") c->SetFrame(BlackFrame());
if (frame == "Button frame") c->SetFrame(ButtonFrame());
if (frame == "Top separator frame") c->SetFrame(TopSeparatorFrame());
if (frame == "Left separator frame") c->SetFrame(LeftSeparatorFrame());
if (frame == "Right separator frame") c->SetFrame(RightSeparatorFrame());
if (frame == "Bottom separator frame") c->SetFrame(BottomSeparatorFrame());
}
}
UpdateItemList();
UpdateChildAllPos();
}
void PropertiesWindow::Generate(FormObject* pI, int index)
{
if (!pI) return;
_Properties.Clear();
_Options.Clear();
_Item = pI;
_Index = index;
String type = pI->Get("Type");
if (type.IsEmpty()) return;
Property("Variable", t_("Variable:"), "EditField", Array<String>() << pI->Get("Variable"));
if (_Headers.GetRowCount() != 1)
{
_Headers.Clear();
_Headers.AddRow(t_("Type:"), type);
}
Property("Font.Height", t_("Font height:"), "EditInt", Array<String>()
<< AsString(pI->GetNumber("Font.Height", 0, 0, 500)));
if (type == "EditField")
{
Property("Style", t_("Style:"), "DropList", Array<String>()
<< pI->Get("Style") << "Text Field" << "Password");
Property("TextAlign", t_("Text align:"), "DropList",
Array<String>() << pI->Get("TextAlign") << "Left" << "Right");
Property("Tip", t_("Tip:"), "EditField", Array<String>() << pI->Get("Tip"));
Property("NotNull", t_("Not null:"), "Option", Array<String>() << pI->Get("NotNull",
"0"));
}
if (type == "EditInt")
{
Property("Min", t_("Min:"), "EditInt", Array<String>() << pI->Get("Min"));
Property("Max", t_("Max:"), "EditInt", Array<String>() << pI->Get("Max"));
Property("Tip", t_("Tip:"), "EditField", Array<String>() << pI->Get("Tip"));
Property("NotNull", t_("Not null:"), "Option", Array<String>() << pI->Get("NotNull",
"0"));
}
if (type == "Label")
{
Color src = DefaultInk();
LoadFromString( src, Decode64(pI->Get("Font.Color", Encode64(StoreAsString(src)))) );
Property("Label", t_("Label:"), "EditField", Array<String>() << pI->Get("Label"));
Property("Text.Align", t_("Text align:"), "DropList",
Array<String>() << pI->Get("Text.Align") << "Left" << "Center" << "Right");
Property("Font.Color", t_("Font color:"), "EditColor", src);
}
if (type == "Button")
{
Property("Label", t_("Label:"), "EditField", Array<String>() << pI->Get("Label"));
Property("Action", t_("Action:"), "EditField", Array<String>() << pI->Get("Action"));
Property("Tip", t_("Tip:"), "EditField", Array<String>() << pI->Get("Tip"));
}
if (type == "Form")
{
Property("Form.PathType", t_("Type of path:"), "DropList",
Array<String>() << pI->Get("Form.PathType") << "Relative" << "Absolute");
Property("Form.Path", t_("Path:"), "EditField", Array<String>() << pI->Get("Form.Path"));
Property("Form.Layout", t_("Layout:"), "EditField", Array<String>() << pI->Get("Form.Layout"));
}
if (type == "TabCtrl")
{
Property("Tab.Content", t_("Tabs:"), "EditTabs", Array<String>()
<< pI->Get("Tab.Content", "[Tabs];"));
}
if (type == "GridCtrl")
{
Property("Grid.Columns", t_("Columns:"), "EditColumns", Array<String>()
<< pI->Get("Grid.Columns", "[Columns];"));
}
Property("Frame", t_("Frame:"), "DropList",
Array<String>()
<< pI->Get("Frame")
<< "Default frame"
<< "Null frame"
<< "Top separator frame"
<< "Left separator frame"
<< "Right separator frame"
<< "Bottom separator frame"
<< "Field frame"
<< "Inset frame"
<< "Outset frame"
<< "Thin inset frame"
<< "Thin outset frame"
<< "Black frame"
<< "Button frame");
_Options.HideRow(0);
_Headers.SetCursor(0);
_Headers.StartEdit();
_Options.SetCursor(0);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Operand* ConstantFolder::LoadFromOffset(Initializer* initializer, const Type* sourceType,
const Type* loadType, __int64 offset) {
DebugValidator::IsNotNull(initializer);
DebugValidator::IsLargerOrEqual(offset, 0);
// If the initializer is an initializer list, try to see at which position
// the initializer indicated by the offset is found.
if(initializer->IsInitializerList()) {
auto initList = static_cast<InitializerList*>(initializer);
if(auto arrayType = sourceType->As<ArrayType>()) {
// If it's an array type we can compute the index directly.
auto elementType = arrayType->ElementType();
__int64 elemSize = TypeInfo::GetSize(elementType, target_);
__int64 childIndex = offset / elemSize;
DebugValidator::IsSmaller(childIndex, arrayType->Size());
// We need to test for the case in which the offset lies between
// two elements in an array. Consider the following case:
// const int a[] = {1,2,3,4};
// *((short*)((char*)a + 3)) - data from both 1 and 2 is loaded.
if((elementType->IsArray() || elementType->IsRecord()) == false) {
__int64 childOffset = offset % elemSize;
__int64 loadSize = TypeInfo::GetSize(loadType, target_);
// Note that this also catches the case when the data to be loaded
// is larger than the size of the array element.
if((childOffset + loadSize) > elemSize) {
return LoadFromMultipleArray(initList, childIndex, childOffset,
arrayType, loadType);
}
}
return LoadFromOffset((*initList)[childIndex], arrayType->ElementType(),
loadType, offset - (childIndex * elemSize));
}
else if(auto recordType = sourceType->As<RecordType>()) {
// For records we need to iterate all the fields
// until we find a suitable one.
auto& fields = recordType->Fields();
for(int i = 0; i < fields.Count(); i++) {
const RecordField& field = fields[i];
__int64 fieldOffset = field.FieldOffset;
__int64 fieldSize = TypeInfo::GetSize(field.FieldType, target_);
if(offset < (fieldOffset + fieldSize)) {
// If we need to load from two fields we give up; most of the time
// it can't be performed (there may be padding between fields),
// it would be complicated and this situation shouldn't actually
// occur in a standard-conforming application.
__int64 loadSize = TypeInfo::GetSize(loadType, target_);
if((offset + loadSize) > (fieldOffset + fieldSize)) {
return nullptr;
}
return LoadFromOffset((*initList)[i], field.FieldType,
loadType, offset - fieldOffset);
}
}
}
// The offset is invalid, give up.
return nullptr;
}
if(initializer->Conversion() == InitConv_PointerToPointer) {
// Frequently used for strings, like in the following example:
// var a int8* = ptop("abcd", int8*)
if(auto stringConst = initializer->Value()->As<StringConstant>()) {
return LoadFromString(stringConst, loadType, offset);
}
// All other cases are not supported.
return nullptr;
}
// We should load the operand from the initializer.
return LoadFromInitializer(initializer, loadType, offset);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Operand* ConstantFolder::LoadFromInitializer(Initializer* initializer, const Type* loadType,
__int64 offset) {
DebugValidator::IsFalse(initializer->IsInitializerList());
bool isNull = false;
bool isZero = false;
// We may be loading from string constant.
if(auto stringConst = initializer->Value()->As<StringConstant>()) {
return LoadFromString(stringConst, loadType, offset);
}
// Exclude initializers that have an incompatible conversion.
if(initializer->Conversion() == InitConv_PointerToInt) {
if(initializer->Value()->IsNullConstant()) {
isZero = true;
}
else {
// Definitely not a constant operand.
return nullptr;
}
}
else if((initializer->Conversion() == InitConv_PointerToPointer) ||
(initializer->Conversion() == InitConv_IntToPointer)) {
if(initializer->Value()->IsNullConstant() || MatchInt(0)(initializer->Value())) {
isNull = true;
}
else {
// Definitely not a constant operand.
return nullptr;
}
}
// It's undefined behavior if we try to load from a null pointer.
if(isNull) {
return GetNullptr(loadType);
}
else if(isZero) {
return GetZeroInt(loadType);
}
// Obtain the value from the initializer. If the offset is not 0, or the
// types don't match, we must extract the value.
// Not that we give up if we are requested to extract a value that is larger
// than the one in the initializer, or if the offset is too large.
Operand* value = initializer->Value();
auto valueType = value->GetType();
if((offset == 0) && (loadType == initializer->Value()->GetType())) {
return initializer->Value();
}
else if((offset > TypeInfo::GetSize(valueType, target_)) ||
(TypeInfo::GetSize(loadType, target_) >
TypeInfo::GetSize(valueType, target_))) {
// This is undefined behavior, because we want to read something that is
// in memory located after the operand, and there are no constraints
// on the way global variables are laid out int memory.
return GetUndefined(loadType);
}
return ExtractFromOperand(value, loadType, offset);
}
