C++ NGL_OUT函数代码示例

void MainWindow::OnCreation()
{
  nuiHTTPRequest request(_T("http://127.0.0.1:8888/"), _T("POST"));
  
  nuiMimeMultiPart mime;
  mime.AddVariable(_T("MyParam"), _T("MyValue"));
  mime.AddFile(_T("rsrc:/css/main.css"), _T("MyFile"));
  mime.Dump(&request);
  
  nuiHTTPResponse* pRes = request.SendRequest();

  nuiHTMLView* pView = new nuiHTMLView();
  AddChild(pView);

  if (pRes)
  {
    NGL_OUT(_T("Result:\n%ls\n"), pRes->GetBodyStr().GetChars());
    pView->SetText(pRes->GetBodyStr());
  }
  else
  {
    NGL_OUT(_T("Unable to send HTTP Request"));
    pView->SetText(_T("Unable to send HTTP Request. Make sure you have launched the local *AMP (* Apache + Mysql + Php) server with the correct doc root."));
  }

  delete pRes;
  

}

bool MainWindow::LoadCSS(const nglPath& rPath)
{
  NGL_OUT("MainWindow::LoadCSS");
  nglIStream* pF = rPath.OpenRead();
  if (!pF)
  {
    NGL_OUT(_T("Unable to open CSS source file '%ls'\n"), rPath.GetChars());
    return false;
  }
  
  nuiCSS* pCSS = new nuiCSS();
  bool res = pCSS->Load(*pF, rPath);
  delete pF;
  
  if (res)
  {
    nuiMainWindow::SetCSS(pCSS);
    NGL_OUT("MainWindow::LoadCSS OK");
    return true;
  }
  
  NGL_OUT(_T("%ls\n"), pCSS->GetErrorString().GetChars());
  
  delete pCSS;
  NGL_OUT("MainWindow::LoadCSS ERROR");
  return false;
}

nuiRect nuiFlowView::CalcIdealSize()
{
  if (mCurrentIdealWidth == 0)
  {
    if (GetObjectName() == "Grid")
    {
      NGL_OUT("Flow Layout %p '%s'\n", this, GetObjectName().GetChars());
    }
  }
  if (mIdealWidth > 0)
  {
    mCurrentIdealWidth = mIdealWidth;
  }
  else if (mRect.GetWidth() > 0)
  {
    mCurrentIdealWidth = mRect.GetWidth();
  }
  nuiRect idealsize = Layout(false, mCurrentIdealWidth);

  if (GetDebug())
  {
    NGL_OUT(_T("nuiFlowView::CalcIdealSize[%f]: %s\n"), mCurrentIdealWidth, idealsize.GetValue().GetChars());
  }

  return idealsize;
}

bool nuiGLPainter::CheckFramebufferStatus()
{
//  return true;
#if 1
  GLint status = glCheckFramebufferStatusNUI(GL_FRAMEBUFFER_NUI);
#if defined(NGL_DEBUG)
  switch (status)
  {
    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_NUI:
    {
      NGL_OUT(_T("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n"));
    } break;
    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_NUI:
    {
      NGL_OUT(_T("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n"));
    } break;
    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_NUI:
    {
      NGL_OUT(_T("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS\n"));
    } break;
    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_NUI:
    {
      NGL_OUT(_T("GL_FRAMEBUFFER_INCOMPLETE_FORMATS\n"));
    } break;
    case GL_FRAMEBUFFER_UNSUPPORTED_NUI:
    {
      NGL_OUT(_T("GL_FRAMEBUFFER_UNSUPPORTED\n"));
    } break;
  }
#endif  
  return (status == GL_FRAMEBUFFER_COMPLETE_NUI);
#endif
}

void nuiTessellator::InternalTessError(GLenum ErrNo)
{
#ifdef __NUI_NO_GL__
  NGL_OUT(_T("nui_glu tessellation error\n"));
#elsif !defined(_OPENGL_ES_)
  NGL_OUT(_T("nui_glu tessellation error: %s\n"), gluErrorString(ErrNo));
#endif
}

// Error callback for handling gameswf messages.
static void  log_callback(bool error, const char* message)
{
#ifdef _DEBUG_
  if (error)
  {
    NGL_OUT(_T("ERROR from GameSWF: %s\n"), message);
  }
  else
  {
    NGL_OUT(_T("GameSWF> %s\n"), message);
  }
#endif
}

bool nuiSWF::Load(const nglPath& rPath)
{
  std::string str(rPath.GetPathName().GetStdString());
  const char* pFlashMovieName = str.c_str();
  int  movie_version = 0;

  StopAutoDraw();

//  gameswf::get_movie_info(pFlashMovieName, &movie_version, &mWidth, &mHeight, &mFPS, &mFrames, &mTags);
//  if (movie_version == 0)
//  {
//    NGL_OUT(_T("error: can't get info about %s\n"), pFlashMovieName);
//    return false;
//  }
//  
//  if (mFPS <= 0.5f)
//  {
//    NGL_OUT(_T("Forcing %f FPS instead of 0\n"), mFPS);
//    mFPS = 12.0f;
//  }
//
//  NGL_OUT(_T("Flash file loaded successfully\nName %s\nVersion %i\nWidth %i\nHeight %i\nFPS %f\n"), pFlashMovieName, movie_version, mWidth, mHeight, mFPS);

  //computeMouseScale(mBounds.extent);

  // Load the actual movie.
  mpMovie = mpPlayer->create_movie(pFlashMovieName);
  if (mpMovie == NULL)
  {
    NGL_OUT(_T("error: can't create a movie from '%s'\n"), pFlashMovieName);
    return false;
  }

  movie_version = mpMovie->get_version();
  mWidth = mpMovie->get_width_pixels();
  mHeight = mpMovie->get_height_pixels();
  mFPS = mpMovie->get_frame_rate();
  mFrames = mpMovie->get_frame_count();
  NGL_OUT(_T("Flash file loaded successfully\nName %s\nVersion %i\nWidth %i\nHeight %i\nFPS %f\n"), pFlashMovieName, movie_version, mWidth, mHeight, mFPS);
  
  mpMovieInterface = mpMovie->create_instance();
  if (mpMovieInterface == NULL)
  {
    NGL_OUT(_T("error: can't create movie instance\n"));
    return false;
  }
  mpMovieInterface->add_ref();
    
  InvalidateLayout();
  return true;
}

bool nuiTranslator::LoadLanguages(const nglPath& rLanguageFilesFolder)
{
  mFiles.clear();
  
  std::list<nglPath> Children;
  rLanguageFilesFolder.GetChildren(&Children);
  
  std::list<nglPath>::iterator it = Children.begin();
  std::list<nglPath>::iterator end = Children.end();
  
  while (it != end)
  {
    const nglPath& rPath(*it);
    NGL_OUT(_T("Localization file: %ls\n"), rPath.GetChars());
    if (rPath.GetExtension() == _T("loc"))
    {
      nglPath p(rPath.GetNodeName());
      nglString n(p.GetRemovedExtension());
      mFiles[n] = rPath;
    }
    
    ++it;
  }
  
  return mFiles.empty();
}

bool nuiTranslator::LoadLanguage(nglIStream* pStream)
{
  nuiCSV csv(_T(','));
  bool res = csv.Load(pStream);
  
  if (!res)
    return false;
    
  const std::vector<std::vector<nglString> >& rDoc(csv.GetDocument());
  
  uint32 count = 0;
  
  for (uint32 i = 0; i < rDoc.size(); i++)
  {
    const std::vector<nglString>& rLine(rDoc[i]);
    if (rLine.size() >= 3)
    {
      AddSentence(rLine[0], rLine[1], rLine[2]);
      count++;
    }
  }
  
  NGL_OUT(_T("Loaded %d translated sentences from %d lines\n"), count, rDoc.size());
  
  return true;
}

void nuiUniformDesc::Dump() const
{
  nglString v;
  int32 count = 0;
  switch (mType)
  {
    case GL_FLOAT:        count = 1; break;
    case GL_FLOAT_VEC2:   count = 2; break;
    case GL_FLOAT_VEC3:   count = 3; break;
    case GL_FLOAT_VEC4:   count = 4; break;

    case GL_FLOAT_MAT2:   count = 2 * 2; break;
    case GL_FLOAT_MAT3:   count = 3 * 3; break;
    case GL_FLOAT_MAT4:   count = 4 * 4; break;

    case GL_INT:          count = 1; break;
    case GL_INT_VEC2:     count = 2; break;
    case GL_INT_VEC3:     count = 3; break;
    case GL_INT_VEC4:     count = 4; break;

    case GL_UNSIGNED_INT: count = 1; break;
    case GL_SAMPLER_2D:   count = 1; break;
    case GL_SAMPLER_CUBE: count = 1; break;

    default:
      NGL_ASSERT(0);
  }

  for (int32 i = 0; i < count * mCount; i++)
    v.Add(mValues.mpFloats[i]).Add(" ");
  NGL_OUT("%s: %s\n", mName.GetChars(), v.GetChars());
}

MainWindow::MainWindow(const nglContextInfo& rContextInfo, const nglWindowInfo& rInfo, bool ShowFPS, const nglContext* pShared )
  : nuiMainWindow(rContextInfo, rInfo, pShared, nglPath(ePathCurrent)), mEventSink(this)
{
  NGL_OUT("MainWindow::MainWindow");
  SetDebugMode(true);
  LoadCSS(_T("rsrc:/css/main.css"));  
}

void nuiFrame::SetTexturePath(const nglPath& rPath)
{
  mTexturePath = rPath;
  nuiTexture* pOld = mpTexture;
  mpTexture = nuiTexture::GetTexture(rPath);

  if (!mpTexture || !mpTexture->IsValid())
  {
    NGL_OUT(_T("nuiFrame::SetTexturePath warning : could not load graphic resource '%ls'\n"), rPath.GetChars());
    return;
  }

  if (GetSourceClientRect() == nuiRect(0,0,0,0))
    SetSourceClientRect(nuiRect(0, 0, mpTexture->GetWidth(), mpTexture->GetHeight()));
  if (pOld)
    pOld->Release();
    
  if (mInterpolated)
  {
    mpTexture->SetMinFilter(GL_LINEAR);
    mpTexture->SetMagFilter(GL_LINEAR);
  }
  else
  {
    mpTexture->SetMinFilter(GL_NEAREST);
    mpTexture->SetMagFilter(GL_NEAREST);
  }
  Changed();
}

bool ProjectGenerator::MsgError(const nglString& error)
{
  nglString msg;
  msg.Format(_T("error %ls"), error.GetChars());
  NGL_OUT(msg);
  nuiMessageBox* pMessageBox = new nuiMessageBox(GetMainWindow(), _T("Project Creator"), msg, eMB_OK);
  pMessageBox->QueryUser();  
  return false;
}

int nuiPath::AddVertexOptim(const nuiPoint& rPoint)
{
  if (!rPoint.IsValid())
  {
    NGL_OUT(_T("Invalid path point: {%f, %f, %f, %f}\n"), rPoint[0], rPoint[1], rPoint[2], rPoint[3]);
    NGL_ASSERT(false);
  }
  if (mVertices.empty() || !(rPoint == mVertices.back()))
    mVertices.push_back(rPoint);
  return mVertices.size()-1;
}

void Generator::ParsePngFiles(const nglPath& rootSource, const nglPath& pngSource, const nglPath& codeSource)
{
  std::list<nglPath> children;
  pngSource.GetChildren(&children);
  
  std::list<nglPath>::iterator it;
  for (it = children.begin(); it != children.end(); ++it)
  {
    const nglPath& child = *it;
    
    if (!child.IsLeaf())
    {
      // recurs.
      ParsePngFiles(rootSource, child, codeSource);
      continue;
    }
    
    if (child.GetExtension().Compare(_T("png"), false))
      continue;
    
    nglString node = child.GetPathName();
    node.DeleteLeft(rootSource.GetPathName().GetLength()+1);
    node.DeleteRight(nglPath(node).GetExtension().GetLength() +1);
    
    nglPath destPath = codeSource + nglPath(node);
    
    NGL_OUT(_T("path '%ls', node '%ls' => destPath '%ls'\n"), child.GetChars(), node.GetChars(), destPath.GetChars());
    
    nglPath destDir = destPath.GetParent();
    if (!destDir.Exists())
      destDir.Create(true);
    
    // and call the generator tool to create .cpp and .h files
    nglString cmd;
    nglString space(_T(" "));
    cmd.Append(mTool).Append(_T(" ")).Append(child.GetChars()).Append(_T(" ")).Append(destPath.GetChars());
    NGL_OUT(_T("command : %ls\n"), cmd.GetChars());
    system(cmd.GetStdString().c_str());
  }
  
}