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); }