/**
* Constructor handles program flow. Gets user menu choice then acts on that.
*/
Controller::Controller() {
bool running = true;
int menuChoice = -1;
do {
menuChoice = view.getMenuChoice();
if (menuChoice == 1) { // add movies
DynArray movieList;
view.getMovies(&movieList);
localMovies.addAllMovies(&movieList);
masterMovies.addMovies(&movieList);
} else if (menuChoice == 2) { // delete movie
string movieTitle = view.deleteMovie();
Movie* removedMovie = localMovies.removeMovie(movieTitle);
for (int i = 0; i < localMovies.getSize(); ++i) {
if (localMovies.movieList[i]->getTitle().compare(movieTitle)
== 0) {
DynArray movieToRemove;
movieToRemove.addMovie(localMovies.movieList[i]);
masterMovies.removeMovies(&movieToRemove);
break;
}
}
delete removedMovie;
} else if (menuChoice == 3) { // list all movies
view.listMovies(&localMovies);
} else if (menuChoice == 4) { // list movies by genre
Genre genre = view.getGenre();
DynArray genreMovies;
for (int i = 0; i < localMovies.getSize(); ++i) {
if (localMovies.movieList[i]->getGenre() == genre) {
genreMovies.addMovie(localMovies.movieList[i]);
}
}
view.listMovies(&genreMovies);
} else if (menuChoice == 0) { // exit
running = false;
} else {
view.displayMessage("Invalid menu option!");
}
} while (running);
}
void printMap(){
for(int i = 0; i<keys->getLength();i++){
cout<< "Key: "<<keys->get(i)<<endl;
valarray->get(i)->display();
cout<<endl;
}
}
int Client::SetExpiry(const ByteString &key, uint64_t expiryTime)
{
int status;
Command* cmd;
ByteString args[2];
DynArray<32> numString;
VALIDATE_CLIENT();
VALIDATE_KEY_LEN(key);
VALIDATE_SAFE();
VALIDATE_WRITE();
numString.Writef("%U", expiryTime);
args[0] = key;
args[1] = numString;
cmd = CreateCommand(KEYSPACECLIENT_SET_EXPIRY, SIZE(args), args);
safeCommands.Append(cmd);
if (IS_BATCHED())
{
result->AppendCommand(cmd);
return KEYSPACE_SUCCESS;
}
result->Close();
result->AppendCommand(cmd);
EventLoop();
status = result->CommandStatus();
return status;
}
// FindPaletteIndex()
// Returns the palette index that most closely matches the given
// RGB value. This only works in Indexed mode. The optional low
// and high values specify the low and hight palette indices to
// to search (inclusive). This is similar to the other
// FindPaletteIndex() functions, but also takes a pointer to a
// DynArray of palette indices to match against.
IMG_BYTE ImageClass::FindPaletteIndex( IMG_BYTE r, IMG_BYTE g, IMG_BYTE b, DynArray<int> &array ) {
if( type != IMAGE_INDEXED )
return 0;
if( array.NumElements() == 0 )
return 0;
IMG_BYTE closest = 0; // Closest index to the target color
int how_close = 1000; // 0 == perfect match
int this_try;
int step = sizeof( IMG_BYTE ) * 3;
IMG_BYTE * rgb = &(palette[ (array[0]) ]);
for( unsigned int i=0; i < array.NumElements(); i++ ) {
rgb = GetPaletteColor( array[i] );
if( r > rgb[0] ) this_try = r - rgb[0]; // Find the red difference
else this_try = rgb[0] - r;
if( g > rgb[1] ) this_try += g - rgb[1]; // Find the green difference
else this_try += rgb[1] - g;
if( b > rgb[2] ) this_try += b - rgb[2]; // Find the blue difference
else this_try += rgb[2] - b;
if( this_try < how_close ) { // See if this is closer than the last match
closest = array[i];
how_close = this_try;
}
}
return closest;
}
int main(int argc, char **argv)
{
init_shogun(&print_message, &print_message, &print_message);
/* create example tree */
CModelSelectionParameters* tree=create_param_tree();
tree->print();
SG_SPRINT("----------------------------------\n");
/* build combinations of parameter trees */
DynArray<CParameterCombination*> combinations;
tree->get_combinations(combinations);
apply_parameter_tree(combinations);
/* print and directly delete them all */
for (index_t i=0; i<combinations.get_num_elements(); ++i)
combinations[i]->destroy(true, true);
/* delete example tree (after processing of combinations because CSGObject
* (namely the kernel) of the tree is SG_UNREF'ed (and not REF'ed anywhere
* else) */
tree->destroy();
exit_shogun();
return 0;
}
// SCWP_Activate
XCALL_ (int) SCWP_Activate( long version, GlobalFunc *global,
void *local, void *serverData ) {
if ( version != LWMODCOMMAND_VERSION )
return AFUNC_BADVERSION;
LWModCommand * command = (LWModCommand *)local;
if( command == NULL )
return AFUNC_BADLOCAL;
// Build a list of parts for the selected polygons
MeshEditOp *op = (command->editBegin)( 0, 0, OPSEL_DIRECT | OPSEL_MODIFY );
parts.Flush();
EDError err = op->polyScan( op->state, SCWP_PolyScan_FindParts, (void *)op, OPLYR_FG );
if( err != EDERR_NONE ) {
op->done( op->state, err, 0 );
} else {
// Select polygons belonging to the selected parts
err = op->polyScan( op->state, SCWP_PolyScan_Select, (void *)op, OPLYR_FG );
op->done( op->state, err, 0 );
}
// Clean up
parts.Flush();
return CSERR_NONE;
}
// SCWSS_PointScan_FindSets():
EDError SCWSS_PointScan_FindSets( void *_op, const EDPointInfo *point ) {
MeshEditOp *op = (MeshEditOp *)_op;
float val;
if( point->flags & EDDF_SELECT ) {
for( int v=0; v < vmap_count; v++ ) {
const char *set_name = object_funcs->vmapName( LWVMAP_PICK, v );
void *set_id = op->pointVSet( op->state, NULL, LWVMAP_PICK, set_name );
if( op->pointVGet( op->state, point->pnt, &val) != 0 ) {
unsigned long i;
for( i=0; i < selection_set_ids.NumElements(); i++ ) {
if( selection_set_ids[i] == set_id )
break;
}
if( i == selection_set_ids.NumElements() ) {
selection_set_ids.Add( set_id );
selection_set_names.Add( StringTools::strdup( set_name ) );
}
}
}
}
return EDERR_NONE;
}
void CEntityPropertyHandler::SetProperty(IEntity *pIEntity, int index, const char *value)
{
EntityId id = pIEntity->GetId();
CMonoEntityExtension *pEntity = nullptr;
if (IGameObject *pGameObject = static_cast<CScriptSystem *>(GetMonoScriptSystem())->GetIGameFramework()->GetGameObject(id))
pEntity = static_cast<CMonoEntityExtension *>(pGameObject->QueryExtension(pIEntity->GetClass()->GetName()));
// Only true after game has started, limiting this to changes made in Editor.
if(pEntity && pEntity->IsInitialized())
pEntity->SetPropertyValue(m_pProperties[index].info, value);
else
{
bool exists = false;
for(auto it = m_queuedProperties.begin(); it != m_queuedProperties.end(); ++it)
{
if((*it).first == id)
{
(*it).second.push_back(SQueuedProperty(m_pProperties[index].info, value));
exists = true;
break;
}
}
if(!exists)
{
DynArray<SQueuedProperty> queuedPropertiesForEntity;
queuedPropertiesForEntity.push_back(SQueuedProperty(m_pProperties[index].info, value));
m_queuedProperties.insert(TQueuedPropertyMap::value_type(id, queuedPropertiesForEntity));
}
}
}
void CClipVolumeProxy::UpdateRenderMesh(IRenderMesh* pRenderMesh, const DynArray<Vec3>& meshFaces)
{
m_pRenderMesh = pRenderMesh;
gEnv->pEntitySystem->ReleaseBSPTree3D(m_pBspTree);
const size_t nFaceCount = meshFaces.size() / 3;
if(nFaceCount > 0)
{
IBSPTree3D::FaceList faceList;
faceList.reserve(nFaceCount);
for(int i=0; i<meshFaces.size(); i+=3)
{
IBSPTree3D::CFace face;
face.push_back(meshFaces[i + 0]);
face.push_back(meshFaces[i + 1]);
face.push_back(meshFaces[i + 2]);
faceList.push_back(face);
}
m_pBspTree = gEnv->pEntitySystem->CreateBSPTree3D(faceList);
}
if(m_pEntity && m_pClipVolume)
gEnv->p3DEngine->UpdateClipVolume(m_pClipVolume, m_pRenderMesh, m_pBspTree, m_pEntity->GetWorldTM(), !m_pEntity->IsHidden(), m_pEntity->GetName());
}
void KChatSocket::Breathe(int msec)
{
JgVirtualSocket::Breathe(msec);
void* packetPtrs[64];
char packetBuffer[10240];
DynArray<void*> packets;
packets.attach(&packetPtrs[0], 64, 0);
KClientGateListener* cgl = KClientGateListener::getSingletonPtr();
while(!m_shouldRemove)
{
int_r packetNum = this->ReadPackets(packetBuffer, sizeof(packetBuffer), packets, 64);
if(packetNum < 1) break;
for(int_r i=0; i<packetNum; i++)
{
JgPacketHead* head = (JgPacketHead*)packets[(int)i];
//cgl->m_gateChatC.Process(this, head);
if(m_shouldRemove) break;
}
}
if(m_shouldRemove)
{
cgl->m_vsocketManager.detach(this);
m_pGatewaySocket->setChatCnn(NULL);
Log(LOG_DEBUG, "debug: free %s", this->ToString().c_str());
this->Destroy();
}
}
int StructuredDatabaseTest()
{
Table* table;
int user_id;
DynArray<1024> what;
DynArray<1024> where;
table = new Table(&database, "structured_test");
table->Truncate();
user_id = InsertUser(table, "dopey", "dopeypass", "online");
InsertEvent(table, user_id, "dinner", "cheezburger", "2009-03-24 01:09:00");
InsertEvent(table, user_id, "meeting", "important", "2009-03-24 11:12:00");
// SELECT * FROM event WHERE user=%d AND date > 2009-03-24 01
what.Printf("event:user:%d", user_id);
where.Printf("date:2009-03-24 01");
//TableSelector selector(what.buffer, where.buffer);
// QuerySelector selector("SELECT date, note FROM event WHERE user_id=%d", user_id);
// table->Visit(selector);
ListTableVisitor visitor;
table->Visit(visitor);
return TEST_SUCCESS;
}
bool Endpoint::Set(const char* ip_port, bool resolv)
{
const char* p;
int port;
bool ret;
DynArray<32> ipbuf;
p = ip_port;
while (*p != '\0' && *p != ':')
p++;
if (*p == '\0')
{
Log_Trace("No ':' in host specification");
return false;
}
ipbuf.Append(ip_port, p - ip_port);
ipbuf.Append("", 1);
p++;
port = -1;
port = atoi(p);
if (port < 1 || port > 65535)
{
Log_Trace("atoi() failed to produce a sensible value");
return false;
}
ret = Set(ipbuf.buffer, port, resolv);
return ret;
}
void SimpleSortedSetData< KeyT, CompareKeyT, AllocatorT >::Serialize( ArchiveT& archive )
{
DynArray< ObjectPtr > components;
components.Reserve( m_Data->GetSize() );
{
DataType::ConstIterator itr = m_Data->Begin();
DataType::ConstIterator end = m_Data->End();
for ( ; itr != end; ++itr )
{
ObjectPtr dataElem = Registry::GetInstance()->CreateInstance( Reflect::GetDataClass< KeyT >() );
// downcast to data type
Data* dataSer = AssertCast< Data >( dataElem );
// connect to our map data memory address
dataSer->ConnectData( const_cast< KeyT* >( &( *itr ) ) );
// serialize to the archive stream
HELIUM_VERIFY( components.New( dataSer ) );
}
}
archive.SerializeArray( components );
DynArray< ObjectPtr >::Iterator itr = components.Begin();
DynArray< ObjectPtr >::Iterator end = components.End();
for ( ; itr != end; ++itr )
{
Data* ser = AssertCast< Data >( *itr );
ser->Disconnect();
// might be useful to cache the data object here
}
}
void SimpleObjectSortedMapData< KeyT, CompareKeyT, AllocatorT >::Deserialize( ArchiveT& archive )
{
DynArray< ObjectPtr > components;
archive.DeserializeArray( components, ArchiveFlags::Sparse );
size_t componentCount = components.GetSize();
if ( componentCount % 2 != 0 )
{
throw Reflect::DataFormatException( TXT( "Unmatched map objects" ) );
}
// if we are referring to a real field, clear its contents
m_Data->Clear();
m_Data->Reserve( componentCount / 2 );
DynArray< ObjectPtr >::Iterator itr = components.Begin();
DynArray< ObjectPtr >::Iterator end = components.End();
while ( itr != end )
{
Data* key = SafeCast< Data >( *itr );
++itr;
Object* value = *itr;
++itr;
if ( key ) // The object value can be null, so don't check it here.
{
KeyT k;
Data::GetValue( key, k );
(*m_Data)[ k ] = value;
}
}
}
void Boot::boot_run() const
{
DynArray<unsigned> boot;
buildBoot(boot,Range(&__std_boot_beg,&__std_boot_end));
__std_boot(boot.getPtr(),boot.getPtr()+boot.getLen());
}
/// Resolve a set of shader preprocessor options from the associated index.
///
/// @param[in] shaderType Type of shader.
/// @param[in] index Option set index.
/// @param[out] rToggleNames List of enabled shader toggles.
/// @param[out] rSelectPairs List shader selection pair values.
void Shader::Options::GetOptionSetFromIndex(
RShader::EType shaderType,
size_t index,
DynArray< Name >& rToggleNames,
DynArray< SelectPair >& rSelectPairs ) const
{
HELIUM_ASSERT( static_cast< size_t >( shaderType ) < static_cast< size_t >( RShader::TYPE_MAX ) );
rToggleNames.Resize( 0 );
rSelectPairs.Resize( 0 );
uint32_t shaderTypeMask = ( 1 << shaderType );
size_t shaderToggleCount = m_toggles.GetSize();
for( size_t shaderToggleIndex = 0; shaderToggleIndex < shaderToggleCount; ++shaderToggleIndex )
{
const Toggle& rShaderToggle = m_toggles[ shaderToggleIndex ];
if( !( rShaderToggle.shaderTypeFlags & shaderTypeMask ) )
{
continue;
}
if( index & 0x1 )
{
HELIUM_VERIFY( rToggleNames.New( rShaderToggle.name ) );
}
index >>= 1;
}
size_t shaderSelectCount = m_selects.GetSize();
for( size_t shaderSelectIndex = 0; shaderSelectIndex < shaderSelectCount; ++shaderSelectIndex )
{
const Select& rShaderSelect = m_selects[ shaderSelectIndex ];
if( !( rShaderSelect.shaderTypeFlags & shaderTypeMask ) )
{
continue;
}
const DynArray< Name >& rShaderSelectChoices = rShaderSelect.choices;
size_t shaderSelectChoiceCount = rShaderSelectChoices.GetSize();
size_t selectIndexMultiplier = shaderSelectChoiceCount + rShaderSelect.bOptional;
size_t selectIndex = index % selectIndexMultiplier;
index /= selectIndexMultiplier;
if( !rShaderSelect.bOptional || selectIndex != shaderSelectChoiceCount )
{
SelectPair* pSelectPair = rSelectPairs.New();
HELIUM_ASSERT( pSelectPair );
pSelectPair->name = rShaderSelect.name;
pSelectPair->choice = rShaderSelectChoices[ selectIndex ];
}
}
}
Reflect::ObjectPtr Helium::Cache::ReadCacheObjectFromBuffer( const DynArray< uint8_t > &_buffer )
{
if (_buffer.GetSize() == 0)
{
Reflect::ObjectPtr null_object;
return null_object;
}
return ReadCacheObjectFromBuffer(_buffer.GetData(), 0, _buffer.GetSize());
}
int count(const char* key){
DynArray<int> * a = valarray->get(keys->indexofVal(key));
int count = 0;
for(int i = 0; i<a->getLength();i++){
if(a->get(i) >= 0){
count++;
}
}
return count;
}
BuilderSlot & take(ulen slot_id)
{
ulen len=bslots.getLen();
if( slot_id>=len )
{
bslots.extend_default(LenAdd(slot_id-len,1));
}
return bslots[slot_id];
}
void SimpleSortedSetData< KeyT, CompareKeyT, AllocatorT >::GetItems( DynArray< DataPtr >& items ) const
{
items.Clear();
items.Reserve( m_Data->GetSize() );
DataType::ConstIterator itr = m_Data->Begin();
DataType::ConstIterator end = m_Data->End();
for ( ; itr != end; ++itr )
{
HELIUM_VERIFY( items.New( Data::Bind( const_cast< KeyT& >( *itr ), m_Instance, m_Field ) ) );
}
}
void CFlashUIGetCompatibleAccessoriesNode ::ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
if(event == eFE_Activate && IsPortActive(pActInfo, 0))
{
string accessories = "";
IActor* pActor = GetInputActor( pActInfo );
if(pActor)
{
IInventory* pInventory = pActor->GetInventory();
if(pInventory)
{
//Get the item ID via the Input string
const string weapon_name = GetPortString(pActInfo, eI_Weapon);
IEntityClassRegistry *pRegistery = gEnv->pEntitySystem->GetClassRegistry();
EntityId item = pInventory->GetItemByClass(pRegistery->FindClass(weapon_name));
//Fetch the actual weapon via the ID
IEntity* pEntity = gEnv->pEntitySystem->GetEntity(item);
if(pEntity)
{
CGameObject * pGameObject = (CGameObject*)pEntity->GetProxy(ENTITY_PROXY_USER);
const char* ext = pGameObject->GetEntity()->GetClass()->GetName();
CWeapon* pWeapon = (CWeapon*)pGameObject->QueryExtension(pGameObject->GetEntity()->GetClass()->GetName());
//If the weapon exists, ask for all compatible accessories
if(pWeapon)
{
//All compatible accessories for this weapon
const DynArray<string> pCompatibleAccessoriesVec = pWeapon->GetCompatibleAccessories();
bool first = true;
DynArray<string>::const_iterator it;
for (it = pCompatibleAccessoriesVec.begin(); it != pCompatibleAccessoriesVec.end(); it++)
{
if (!first)
accessories.append(",");
accessories.append((*it));
first = false;
}
}
}
}
}
//return, if 'accessories' is empty, it has no compatible attachments, or the weapon/inventory was invalid
ActivateOutput(pActInfo, eO_OnCall, true);
ActivateOutput(pActInfo, eO_Args, accessories);
}
}
int main (int argl, char ** argc) {
DynArray <char *> files;
for (int i=1; i<argl; ++i) {
if (argc [i][0] == '-') {
if (string (argc [i]) == "--help") {
printHelp (argc [0]);
return 0;
}
} else {
files.push_back (argc [i]);
}
}
if (files.empty ()) {
string line, prog;
while (std::getline (std::cin, line)) {
if (not line.empty ()) {
prog += line + "\n";
} else if (not prog.empty ()) {
auto n = parse (prog);
print (n);
delete n;
std::cout << std::endl;
prog = line;
}
}
if (not prog.empty()) {
auto n = parse (prog);
print (n);
delete n;
}
} else {
for (char * f : files) {
std::ifstream fin (f);
string buff, prog;
while (std::getline (fin, buff)) prog += buff + "\n";
std::cout << "########" << f << "########" << std::endl;
auto n = parse (prog);
print (n);
delete n;
std::cout << "########" << f << "########" << std::endl;
}
}
return 0;
}
void StructureDynArrayData::Serialize( ArchiveT& archive )
{
const Structure *structure = GetInternalStructure();
DynArray< ObjectPtr > components;
components.Resize( structure->m_DynArrayAdapter->GetSize(GetInternalPtr(structure)) );
for (size_t i = 0; i < components.GetSize(); ++i)
{
components[i] = structure->m_DynArrayAdapter->GetItem(GetInternalPtr(structure), i, m_Instance, m_Field);
}
archive.SerializeArray( components );
}
void CEditorGame::InitLevelTypesEnums(IGameToEditorInterface* pGTE)
{
DynArray<string>* levelTypes;
levelTypes = g_pGame->GetIGameFramework()->GetILevelSystem()->GetLevelTypeList();
const char** allLevelTypes = new const char*[levelTypes->size()];
for (int i = 0; i < levelTypes->size(); i++)
{
PREFAST_ASSUME(i > 0 && i < levelTypes->size());
allLevelTypes[i] = (*levelTypes)[i];
}
pGTE->SetUIEnums("level_types", allLevelTypes, levelTypes->size());
delete[] allLevelTypes;
}
void StructureDynArrayData::Deserialize( ArchiveT& archive )
{
const Structure *structure = GetInternalStructure();
DynArray< ObjectPtr > components;
archive.DeserializeArray(components);
// if we are referring to a real field, clear its contents
structure->m_DynArrayAdapter->Resize(GetInternalPtr(structure), components.GetSize());
for (size_t i = 0; i < components.GetSize(); ++i)
{
Data* data = SafeCast<Data>(components[i]);
structure->m_DynArrayAdapter->SetItem(GetInternalPtr(structure), i, data, m_Instance, m_Field);
}
}
GT create_graph()
{
GT g;
DynArray<typename GT::Node*> nodes; nodes.reserve(V);
for (int i = 0; i < V; ++i)
nodes(i) = g.insert_node(i);
for (int i = 0; i < V - 1; ++i)
{
typename GT::Node * src = nodes(i);
for (int j = i + 1; j < V; ++j)
g.insert_arc(src, nodes(j), i + j);
}
return std::move(g);
}
bool CFlowGraphDebugger::GetBreakpoints(DynArray<SBreakPoint>& breakpointsDynArray)
{
if (m_DebugInfo.empty())
{
return false;
}
TDebugInfo::const_iterator iterDebugInfo = m_DebugInfo.begin();
for (iterDebugInfo; iterDebugInfo != m_DebugInfo.end(); ++iterDebugInfo)
{
TFlowNodesDebugInfo flownodesDebugInfo = (*iterDebugInfo).second;
TFlowNodesDebugInfo::const_iterator iterNodesDebugInfo = flownodesDebugInfo.begin();
for (iterNodesDebugInfo; iterNodesDebugInfo != flownodesDebugInfo.end(); ++iterNodesDebugInfo)
{
SBreakPoints breakpoints = (*iterNodesDebugInfo).second;
// Fill with INPUT port breakpoints
FillDynArray(breakpointsDynArray, breakpoints.inputPorts, (*iterDebugInfo).first, (*iterNodesDebugInfo).first, false);
// Fill with OUTPUT port breakpoints
FillDynArray(breakpointsDynArray, breakpoints.outputPorts, (*iterDebugInfo).first, (*iterNodesDebugInfo).first, true);
}
}
if (breakpointsDynArray.empty())
{
return false;
}
return true;
}
INT_PTR CALLBACK SquerProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
TCHAR szText[80];
wsprintf(szText, _T("HELLO WORLD!"));
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDOK:
{
int x1 = GetDlgItemInt(hDlg, IDC_X1, 0, 0);
int y1 = GetDlgItemInt(hDlg, IDC_Y1, 0, 0);
int x2 = GetDlgItemInt(hDlg, IDC_X2, 0, 0);
int y2 = GetDlgItemInt(hDlg, IDC_Y2, 0, 0);
pic.Add(new Squer(Point(x1, y1), Point(x2, y2)));
}
case IDCANCEL:
EndDialog(hDlg, wmId);
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
INT_PTR CALLBACK CircleProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDOK:
{
int x = GetDlgItemInt(hDlg, IDC_X, 0, 0);
int y = GetDlgItemInt(hDlg, IDC_Y, 0, 0);
int r = GetDlgItemInt(hDlg, IDC_RADIUS, 0, 0);
pic.Add(new Circle(Point(x,y), r));
}
case IDCANCEL:
EndDialog(hDlg, wmId);
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
void Boot::boot_flash(ulen off) const
{
DynArray<unsigned> boot;
buildBoot(boot);
const unsigned WS = sizeof (unsigned) ; // 4, unsigned == uint32
if( boot.getLen()>(MaxFlashLen-BootDataOff)/WS )
{
Printf(Exception,"CCore::Boot::boot_flash() : too large boot");
}
ulen len=boot.getLen()*WS+BootDataOff;
ulen block_count=(len+Flash::BlockSize-1)/Flash::BlockSize;
ulen block_index=off/Flash::BlockSize;
for(ulen ind=block_index,lim=ind+block_count; ind<lim ;ind++)
if( !Flash::Erase(ind) )
{
Flash::ReadMode();
Printf(Exception,"CCore::Boot::boot_flash() : flash erase failure");
}
else
{
Printf(Con,"Block #; erased\n",ind);
}
if( !Flash::Write(off+BootDataOff,Range_const(boot)) )
{
Flash::ReadMode();
Printf(Exception,"CCore::Boot::boot_flash() : flash write failure");
}
PtrLen<const uint32> boot_code=Range(&__std_bootflash_beg,&__std_bootflash_end);
if( !Flash::Write(off,boot_code) )
{
Flash::ReadMode();
Printf(Exception,"CCore::Boot::boot_flash() : flash write failure");
}
}
