void LayerConv::Backward(Layer *prev_layer) {
StartTimer();
prev_layer->deriv_mat_.resize(prev_layer->batchsize_, prev_layer->length_);
#if COMP_REGIME != 2
std::vector< std::vector<Mat> > prev_deriv, filters, deriv;
InitMaps(prev_layer->deriv_mat_, prev_layer->mapsize_, prev_deriv);
InitMaps(weights_.get(), filtersize_, filters);
InitMaps(deriv_mat_, mapsize_, deriv);
std::vector<size_t> padding_der(numdim_);
for (size_t i = 0; i < numdim_; ++i) {
padding_der[i] = filtersize_[i] - 1 - padding_[i];
}
prev_layer->deriv_mat_.assign(0);
#if COMP_REGIME == 1
#pragma omp parallel for num_threads(12) schedule(static,10)
#endif
for (int k = 0; k < batchsize_; ++k) {
#if COMP_REGIME == 1
//#pragma omp parallel for
#endif
for (size_t i = 0; i < outputmaps_; ++i) {
for (size_t j = 0; j < prev_layer->outputmaps_; ++j) {
Mat der_mat(prev_layer->mapsize_);
Filter(deriv[k][i], filters[i][j], padding_der, true, der_mat);
prev_deriv[k][j] += der_mat;
}
}
}
#else // GPU
ImgActs(deriv_mat_, weights_.get(), prev_layer->deriv_mat_,
prev_layer->mapsize_, filtersize_[0], padding_[0], !unshared_);
#endif
prev_layer->deriv_mat_.Validate();
MeasureTime("Backwards Conv Layer",1);
}
void LayerConv::CalcWeights(Layer *prev_layer, int passnum) {
StartTimer();
if (passnum < 2) return;
Mat weights_der;
if (passnum == 2) {
weights_der.attach(weights_.der());
} else if (passnum == 3) {
weights_der.attach(weights_.der2());
}
#if COMP_REGIME != 2
std::vector< std::vector<Mat> > prev_activ, filters_der, deriv;
InitMaps(prev_layer->activ_mat_, prev_layer->mapsize_, prev_activ);
InitMaps(weights_der, filtersize_, filters_der);
InitMaps(deriv_mat_, mapsize_, deriv);
size_t i,j;
int k;
//#pragma omp parallel{ //for num_threads(12) private(fil_der)
for (i = 0; i < outputmaps_; ++i) {
for (j = 0; j < prev_layer->outputmaps_; ++j) {
Mat fil_der(filtersize_);
fil_der.assign(0);
#if COMP_REGIME == 1
#endif
for (k = 0; k < batchsize_; ++k) {
Mat ker_mat(filtersize_);
Filter(prev_activ[k][j], deriv[k][i], padding_, false, ker_mat);
#if COMP_REGIME == 1
//#pragma omp critical
#endif
fil_der += ker_mat;
}
filters_der[i][j] = fil_der;
}
}
#else // GPU
WeightActs(prev_layer->activ_mat_, deriv_mat_, weights_der,
prev_layer->mapsize_, filtersize_[0],
padding_[0], sum_width_, !unshared_);
#endif
weights_der /= (ftype) batchsize_;
weights_der.Validate();
if (passnum == 2) {
mexAssert(deriv_mat_.order() == false, "deriv_mat_.order() should be false");
if (!unshared_) {
deriv_mat_.reshape(batchsize_ * deriv_mat_.size2() / outputmaps_, outputmaps_);
Sum(deriv_mat_, biases_.der(), 1);
deriv_mat_.reshape(batchsize_, deriv_mat_.size1() * outputmaps_ / batchsize_);
} else {
Sum(deriv_mat_, biases_.der(), 1);
}
(biases_.der() /= (ftype) batchsize_) *= bias_coef_;
biases_.der().Validate();
}
MeasureTime("CalcWeights Conv Layer",2);
}
void LayerJitt::Forward(Layer *prev_layer, int passnum) {
if (passnum == 3) return;
// for testing just central cropping
if (passnum == 0) {
shift_.assign(numdim_, 0);
scale_.assign(numdim_, 1);
mirror_.assign(numdim_, false);
angle_ = 0;
}
batchsize_ = prev_layer->batchsize_;
activ_mat_.resize(batchsize_, length_);
#if COMP_REGIME != 2
std::vector< std::vector<Mat> > prev_activ, activ;
InitMaps(prev_layer->activ_mat_, prev_layer->mapsize_, prev_activ);
InitMaps(activ_mat_, mapsize_, activ);
#if COMP_REGIME == 1
#pragma omp parallel for
#endif
for (int k = 0; k < batchsize_; ++k) {
std::vector<ftype> shift(numdim_, 0);
std::vector<ftype> scale(numdim_, 1);
std::vector<bool> mirror(numdim_, false);
ftype angle = 0;
for (size_t j = 0; j < numdim_; ++j) {
if (shift_[j] > 0) {
shift[j] = ((ftype) std::rand() / RAND_MAX * 2 - 1) * shift_[j];
}
if (scale_[j] > 1) {
scale[j] = pow(scale_[j], (ftype) std::rand() / RAND_MAX * 2 - 1);
}
if (mirror_[j]) {
mirror[j] = ((ftype) std::rand() / RAND_MAX * 2 - 1 > 0);
}
}
if (angle_ > 0) {
angle = ((ftype) std::rand() / RAND_MAX * 2 - 1) * kPi * angle_;
}
for (size_t i = 0; i < outputmaps_; ++i) {
Transform(prev_activ[k][i], shift, scale, mirror, angle, defval_, activ[k][i]);
}
}
#else // GPU
TransformActs(prev_layer->activ_mat_, activ_mat_, prev_layer->mapsize_,
mapsize_, shift_, scale_, mirror_, angle_, defval_);
#endif
activ_mat_.Validate();
/*
for (int i = 0; i < 5; ++i) {
mexPrintMsg("Jitt: activ_[0][0]", activ_[0][0](0, i));
} */
}
void LayerConv::Forward(Layer *prev_layer, int passnum) {
StartTimer();
batchsize_ = prev_layer->batchsize_;
if (passnum == 3) {
Swap(activ_mat_, first_mat_);
}
activ_mat_.resize(batchsize_, length_);
#if COMP_REGIME != 2
std::vector< std::vector<Mat> > prev_activ, filters, activ;
InitMaps(prev_layer->activ_mat_, prev_layer->mapsize_, prev_activ);
InitMaps(weights_.get(), filtersize_, filters);
InitMaps(activ_mat_, mapsize_, activ);
activ_mat_.assign(0);
#if COMP_REGIME == 1
#pragma omp parallel for num_threads(12)
#endif
for (int k = 0; k < batchsize_; ++k) {
#if COMP_REGIME == 1
//#pragma omp parallel for
#endif
for (size_t i = 0; i < outputmaps_; ++i) {
for (size_t j = 0; j < prev_layer->outputmaps_; ++j) {
Mat act_mat(mapsize_);
Filter(prev_activ[k][j], filters[i][j], padding_, false, act_mat);
activ[k][i] += act_mat;
}
}
}
#else // GPU
FilterActs(prev_layer->activ_mat_, weights_.get(), activ_mat_,
prev_layer->mapsize_, filtersize_[0], padding_[0], !unshared_);
#endif
if (passnum == 0 || passnum == 1) {
mexAssert(activ_mat_.order() == false, "activ_mat_.order() should be false");
if (!unshared_) {
activ_mat_.reshape(activ_mat_.size1() * activ_mat_.size2() / outputmaps_, outputmaps_);
activ_mat_.AddVect(biases_.get(), 1);
activ_mat_.reshape(batchsize_, activ_mat_.size1() * activ_mat_.size2() / batchsize_);
} else {
activ_mat_.AddVect(biases_.get(), 1);
}
}
activ_mat_.Validate();
MeasureTime("Forwards Conv Layer",0);
}
void LayerTrim::Backward(Layer *prev_layer) {
if (prev_layer->type_ == "i" || prev_layer->type_ == "j") return;
prev_layer->deriv_mat_.resize(prev_layer->batchsize_, prev_layer->length_);
prev_layer->deriv_.assign(prev_layer->batchsize_, std::vector<Mat>(prev_layer->outputmaps_));
InitMaps(prev_layer->deriv_mat_, prev_layer->mapsize_, prev_layer->deriv_);
for (size_t k = 0; k < batchsize_; ++k) {
for (size_t i = 0; i < outputmaps_; ++i) {
prev_layer->deriv_[k][i].resize(prev_layer->mapsize_);
MaxTrimDer(deriv_[k][i], coords_[k][i], prev_layer->deriv_[k][i]);
}
}
}
HRESULT STDMETHODCALLTYPE initModule(IDirect3D9* self, UINT Adapter,
D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags,
D3DPRESENT_PARAMETERS *pPresentationParameters,
IDirect3DDevice9** ppReturnedDeviceInterface) {
unhookFunction(hk_D3D_CreateDevice, initModule);
LOG(L"Initializing Bootserver");
getConfig("bootserv", "debug", DT_DWORD, 1, bootservConfig);
getConfig("bootserv", "online.enabled", DT_DWORD, 2, bootservConfig);
getConfig("bootserv", "random.enabled", DT_DWORD, 3, bootservConfig);
getConfig("bootserv", "random.skip", DT_STRING, 4, bootservConfig);
HookCallPoint(code[C_GET_BOOT_ID1] + 4,
bootservAtGetBootIdCallPointA, 6, 14);
HookCallPoint(code[C_GET_BOOT_ID2] + 4,
bootservAtGetBootIdCallPointA, 6, 14);
HookCallPoint(code[C_GET_BOOT_ID3] + 3,
bootservAtGetBootIdCallPointB, 6, 13);
HookCallPoint(code[C_GET_BOOT_ID4] + 3,
bootservAtGetBootIdCallPointC, 6, 19);
HookCallPoint(code[C_GET_BOOT_ID5] + 4,
bootservAtGetBootIdCallPointA, 6, 15);
HookCallPoint(code[C_GET_BOOT_ID6] + 4,
bootservAtGetBootIdCallPointA, 6, 14);
HookCallPoint(code[C_PROCESS_BOOT_ID],
bootservAtProcessBootIdCallPoint, 3, 1);
HookCallPoint(code[C_ENTRANCE_BOOTS],
bootservEntranceBootsCallPoint, 6, 1);
// initialize boots map
InitMaps();
// register callbacks
afsioAddCallback(bootservGetFileInfo);
addCopyPlayerDataCallback(bootservCopyPlayerData);
addWriteEditDataCallback(bootservWriteEditData);
// Random boots on each match doesn't yet work well,
// because we need to make sure the boots aren't re-mapped
// in the middle of boot loading operation!
//
//if (_bootserv_config._random_boots)
// addOverlayCallback(bootservOverlayEvent,false);
TRACE(L"Hooking done.");
return D3D_OK;
}
void LayerTrim::Forward(Layer *prev_layer, bool istrain) {
batchsize_ = prev_layer->batchsize_;
activ_mat_.resize(batchsize_, length_);
activ_.assign(batchsize_, std::vector<Mat>(outputmaps_));
InitMaps(activ_mat_, mapsize_, activ_);
coords_.resize(batchsize_);
for (size_t k = 0; k < batchsize_; ++k) {
coords_[k].resize(outputmaps_);
for (size_t i = 0; i < outputmaps_; ++i) {
coords_[k][i].resize(2);
MaxTrim(prev_layer->activ_[k][i], coords_[k][i], activ_[k][i]);
}
}
if (!istrain) prev_layer->activ_mat_.clear();
}
BOOL CstarterDlg::OnInitDialog()
{
CDialogEx::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
regvals_t regVals;
ReadRegistry(regVals);
InitResolutions();
InitMaps();
int resId = m_cbResolution.FindStringExact(-1, regVals.resolution);
if(resId == CB_ERR)
m_cbResolution.AddString(regVals.resolution);
m_cbResolution.SelectString(-1, regVals.resolution);
m_bFullscreen.SetCheck(regVals.fullscreenChoice);
m_iConnectChoice = regVals.connectChoice;
m_eIP.SetWindowText(regVals.ip);
std::set<TCHAR> charset;
for(TCHAR c = _T('a'); c <= _T('z'); c++)
charset.insert(c);
for(TCHAR c = _T('A'); c <= _T('Z'); c++)
charset.insert(c);
for(TCHAR c = _T('0'); c <= _T('9'); c++)
charset.insert(c);
charset.insert('_');
m_eNickname.SetMask(charset);
m_eNickname.SetWindowText(regVals.nickname);
if(!regVals.map.IsEmpty())
m_cbMap.SetWindowText(regVals.map);
else
m_cbMap.SetCurSel(0);
UpdateData(FALSE);
return TRUE; // return TRUE unless you set the focus to a control
}
void LayerJitter::Forward(Layer *prev_layer, int passnum) {
batchsize_ = prev_layer->batchsize_;
activ_mat_.resize(batchsize_, length_);
InitMaps(activ_mat_, mapsize_, activ_);
#if USE_MULTITHREAD == 1
#pragma omp parallel for
#endif
for (int k = 0; k < batchsize_; ++k) {
for (size_t i = 0; i < outputmaps_; ++i) {
std::vector<ftype> shift(numdim_, 0);
std::vector<ftype> scale(numdim_, 1);
std::vector<bool> mirror(numdim_, false);
ftype angle = 0;
for (size_t j = 0; j < numdim_; ++j) {
if (shift_[j] > 0) {
shift[j] = ((ftype) rand() / RAND_MAX * 2 - 1) * shift_[j];
}
if (scale_[j] > 1) {
scale[j] = pow(scale_[j], (ftype) rand() / RAND_MAX * 2 - 1);
}
if (mirror_[j]) {
mirror[j] = ((ftype) rand() / RAND_MAX > 0.5);
}
}
if (angle_ > 0) {
angle = ((ftype) rand() / RAND_MAX * 2 - 1) * M_PI * angle_;
}
Transform(prev_layer->activ_[k][i], shift, scale, mirror, angle, default_, activ_[k][i]);
}
}
activ_mat_.Validate();
/*
for (int i = 0; i < 5; ++i) {
mexPrintMsg("Jitt: activ_[0][0]", activ_[0][0](0, i));
} */
}
void mexFunction(int nLhs, mxArray* pLhs[], int nRhs, const mxArray* pRhs[]) {
mexAssert(NARGIN_MIN <= nRhs && nRhs <= NARGIN_MAX, "Number of input arguments in wrong!");
mexAssert(nLhs == NARGOUT, "Number of output arguments is wrong!" );
mexAssert(mexIsCell(IN_L), "Layers must be the cell array");
mexAssert(mexGetNumel(IN_L) == 2, "Layers array must contain 2 cells");
mexAssert(mexIsCell(IN_W), "Weights must be the cell array");
mexAssert(mexGetNumel(IN_W) == 2, "Weights array must contain 2 cells");
Net net;
mxArray *mx_weights;
net.InitLayers(mexGetCell(IN_L, 1));
net.InitWeights(mexGetCell(IN_W, 1), mx_weights);
net.InitParams(IN_P);
net.ReadLabels(IN_Y);
const mxArray *mx_imweights = mexGetCell(IN_W, 0);
size_t train_num = net.labels_.size1();
mexAssert(train_num == mexGetNumel(mx_imweights),
"Weights and labels number must coincide");
bool is_multicoords = false;
if (mexIsCell(IN_X)) {
mexAssert(train_num == mexGetNumel(IN_X),
"Coordinates and labels number must coincide");
is_multicoords = true;
}
Params params_ = net.params_;
size_t numbatches = (size_t) ceil((ftype) train_num/params_.batchsize_);
Mat trainerror_(params_.numepochs_, numbatches);
Mat trainerror2_(params_.numepochs_, numbatches);
trainerror2_.assign(0);
std::vector<Net> imnets;
imnets.resize(params_.batchsize_);
for (size_t i = 0; i < params_.batchsize_; ++i) {
imnets[i].InitLayers(mexGetCell(IN_L, 0));
if (!is_multicoords) {
imnets[i].ReadData(IN_X);
} else {
imnets[i].ReadData(mexGetCell(IN_X, i)); // just to get pixels_num
}
}
size_t pixels_num = imnets[0].data_.size1();
Layer *firstlayer = net.layers_[0];
size_t dimens_num = firstlayer->outputmaps_;
mexAssert(imnets[0].layers_.back()->length_ == dimens_num,
"Final layer length must coincide with the number of outputmaps");
mexAssert(pixels_num == firstlayer->mapsize_[0] * firstlayer->mapsize_[1],
"Pixels number must coincide with the first layer elements number");
std::vector<size_t> pred_size(2);
pred_size[0] = 1; pred_size[1] = pixels_num * dimens_num;
Mat images_mat, labels_batch, pred_batch, pred_pixels;
std::vector< std::vector<Mat> > images, images_der;
for (size_t epoch = 0; epoch < params_.numepochs_; ++epoch) {
std::vector<size_t> randind(train_num);
for (size_t i = 0; i < train_num; ++i) {
randind[i] = i;
}
if (params_.shuffle_) {
std::random_shuffle(randind.begin(), randind.end());
}
std::vector<size_t>::const_iterator iter = randind.begin();
for (size_t batch = 0; batch < numbatches; ++batch) {
size_t batchsize = std::min(params_.batchsize_, (size_t)(randind.end() - iter));
std::vector<size_t> batch_ind = std::vector<size_t>(iter, iter + batchsize);
iter = iter + batchsize;
labels_batch = SubMat(net.labels_, batch_ind, 1);
net.UpdateWeights(epoch, false);
images_mat.resize(batchsize, pred_size[1]);
InitMaps(images_mat, pred_size, images);
// first pass
for (size_t m = 0; m < batchsize; ++m) {
imnets[m].InitWeights(mexGetCell(mx_imweights, batch_ind[m]));
if (is_multicoords) {
imnets[m].ReadData(mexGetCell(IN_X, batch_ind[m]));
}
imnets[m].InitActiv(imnets[m].data_);
imnets[m].Forward(pred_pixels, 1);
images[m][0].copy(Trans(pred_pixels).reshape(pred_size[0], pred_size[1]));
}
net.InitActiv(images_mat);
net.Forward(pred_batch, 1);
/*
for (int i = 0; i < 5; ++i) {
mexPrintMsg("pred_batch1", pred_batch(0, i));
}*/
// second pass
net.InitDeriv(labels_batch, trainerror_(epoch, batch));
net.Backward();
net.CalcWeights();
InitMaps(firstlayer->deriv_mat_, pred_size, images_der);
for (size_t m = 0; m < batchsize; ++m) {
imnets[m].layers_.back()->deriv_mat_ = Trans(images_der[m][0].reshape(dimens_num, pixels_num));
imnets[m].Backward();
}
// third pass
ftype loss2 = 0, curloss = 0, invind = 0;
std::vector<size_t> invalid;
for (size_t m = 0; m < batchsize; ++m) {
imnets[m].InitDeriv2(curloss);
if (curloss > 0) {
imnets[m].Forward(pred_pixels, 3);
images[m][0].copy(Trans(pred_pixels).reshape(pred_size[0], pred_size[1]));
loss2 += curloss;
} else {
invalid.push_back(m);
}
}
if (invalid.size() < batchsize) {
loss2 /= (batchsize - invalid.size());
trainerror2_(epoch, batch) = loss2;
net.InitActiv(images_mat);
net.Forward(pred_batch, 3);
}
net.CalcWeights2(invalid);
// weights update
net.UpdateWeights(epoch, true);
if (params_.verbose_ == 2) {
std::string info = std::string("Epoch: ") + std::to_string(epoch+1) +
std::string(", batch: ") + std::to_string(batch+1);
mexPrintMsg(info);
}
} // batch
if (params_.verbose_ == 1) {
std::string info = std::string("Epoch: ") + std::to_string(epoch+1);
mexPrintMsg(info);
}
} // epoch
//mexPrintMsg("Training finished");
//net.weights_.get().copy(net.weights_.der());
OUT_W = mexSetCellMat(1, 2);
mexSetCell(OUT_W, 0, mexDuplicateArray(mx_imweights));
mexSetCell(OUT_W, 1, mx_weights);
OUT_E = mexSetCellMat(1, 2);
mexSetCell(OUT_E, 0, mexSetMatrix(trainerror_));
mexSetCell(OUT_E, 1, mexSetMatrix(trainerror2_));
}
//**************************************************************************************************************
//
// Init
//
// connect the object class to the decoration method
//
void nuiDefaultDecoration::Init()
{
nuiInitDefaultDecorationAtlas();
InitColors();
InitSelection();
InitMaps();
InitIcons();
InitImages();
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiLabel")), &nuiDefaultDecoration::Label);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiEditText")), &nuiDefaultDecoration::EditText);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiEditLine")), &nuiDefaultDecoration::EditLine);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiSplitter")), &nuiDefaultDecoration::Splitter);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiTitledPane")), &nuiDefaultDecoration::TitledPane);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFolderPane")), &nuiDefaultDecoration::FolderPane);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiButton")), &nuiDefaultDecoration::Button);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiRadioButton")), &nuiDefaultDecoration::RadioButton);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiCloseButton")), &nuiDefaultDecoration::CloseButton);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiToggleButton")), &nuiDefaultDecoration::ToggleButton);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiKnob")), &nuiDefaultDecoration::KnobSequence);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiComboBox")), &nuiDefaultDecoration::ComboBox);
// dialogs
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiDialog::Title")), &nuiDefaultDecoration::Dialog_Title);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiDialog::EditLine")), &nuiDefaultDecoration::Dialog_EditLine);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiMessageBox::Title")), &nuiDefaultDecoration::MessageBox_Title);
// FileSelector
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::FolderView")), &nuiDefaultDecoration::FileSelector_FolderView);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::InfoView")), &nuiDefaultDecoration::FileSelector_InfoView);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::FolderLabel")), &nuiDefaultDecoration::FileSelector_FolderLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::VolumeIcon")), &nuiDefaultDecoration::FileSelector_VolumeIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::FolderIcon")), &nuiDefaultDecoration::FileSelector_FolderIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::TreeView")), &nuiDefaultDecoration::FileSelector_TreeView);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::TreeFolderLabel")), &nuiDefaultDecoration::FileSelector_TreeFolderLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::TreeFileLabel")), &nuiDefaultDecoration::FileSelector_TreeFileLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::TreeFolderIcon")), &nuiDefaultDecoration::FileSelector_TreeFolderIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileSelector::TreeFileIcon")), &nuiDefaultDecoration::FileSelector_TreeFileIcon);
// FileTree
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree")), &nuiDefaultDecoration::FileTree_View);
// nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::Node")), &nuiDefaultDecoration::FileTree_Node);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::ColumnLabel")), &nuiDefaultDecoration::FileTree_ColumnLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::VolumeLabel")), &nuiDefaultDecoration::FileTree_FolderLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::FolderLabel")), &nuiDefaultDecoration::FileTree_FolderLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::FileLabel")), &nuiDefaultDecoration::FileTree_FileLabel);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::FileInfo")), &nuiDefaultDecoration::FileTree_FileInfo);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::VolumeIcon")), &nuiDefaultDecoration::FileTree_VolumeIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::FolderIcon")), &nuiDefaultDecoration::FileTree_FolderIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::OpenFolderIcon")), &nuiDefaultDecoration::FileTree_OpenFolderIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::ParentFolderIcon")), &nuiDefaultDecoration::FileTree_ParentFolderIcon);
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiFileTree::FileIcon")), &nuiDefaultDecoration::FileTree_FileIcon);
// NavigationViews
nuiWidget::SetDefaultDecoration(nuiObject::GetClassNameIndex(_T("nuiNavigationBar")), &nuiDefaultDecoration::NavigationBar);
App->AddExit(nuiDefaultDecoration::Exit);
}
