void CBrowserView::OnSaveLinkAs()
{
    if(! mCtxMenuLinkUrl.Length())
        return;

    // Try to get the file name part from the URL
    // To do that we first construct an obj which supports
    // nsIRUI interface. Makes it easy to extract portions
    // of a URL like the filename, scheme etc. + We'll also
    // use it while saving this link to a file
    nsresult rv   = NS_OK;
    nsCOMPtr<nsIURI> linkURI;
    rv = NS_NewURI(getter_AddRefs(linkURI), mCtxMenuLinkUrl);
    if (NS_FAILED(rv))
        return;

    // Get the "path" portion (see nsIURI.h for more info
    // on various parts of a URI)
    nsCAutoString fileName;
    linkURI->GetPath(fileName);

    // The path may have the "/" char in it - strip those
    fileName.StripChars("\\/");

    // Now, use this file name in a File Save As dlg...

    char *lpszFilter =
        "HTML Files (*.htm;*.html)|*.htm;*.html|"
        "Text Files (*.txt)|*.txt|"
        "All Files (*.*)|*.*||";

    const char *pFileName = fileName.Length() ? fileName.get() : NULL;

    CFileDialog cf(FALSE, "htm", pFileName, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                   lpszFilter, this);
    if(cf.DoModal() == IDOK)
    {
        CString strFullPath = cf.GetPathName();

        nsCOMPtr<nsIWebBrowserPersist> persist(do_QueryInterface(mWebBrowser));
//		if(persist)
//			persist->SaveURI(linkURI, nsnull, strFullPath.GetBuffer(0));
    }
}

    virtual void onDraw(SkCanvas* canvas) {
        void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = {
            draw_sprite, draw_bitmap, draw_path, draw_paint, draw_text
        };

        SkAutoTUnref<SkColorFilter> cf(
            SkColorFilter::CreateModeFilter(SK_ColorMAGENTA, SkXfermode::kSrcIn_Mode));
        SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get()));
        SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
                                         SkImageFilter::CropRect::kHasAll_CropEdge);
        SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)),
                                          SkImageFilter::CropRect::kHasAll_CropEdge);

        SkImageFilter* filters[] = {
            NULL,
            new SkDropShadowImageFilter(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE),
            new SkDropShadowImageFilter(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE),
            new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE),
            new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, cfif),
            new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, NULL, &cropRect),
            new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, NULL, &bogusRect),
        };

        SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
        SkScalar MARGIN = SkIntToScalar(16);
        SkScalar DX = r.width() + MARGIN;
        SkScalar DY = r.height() + MARGIN;

        canvas->translate(MARGIN, MARGIN);
        for (size_t j = 0; j < SK_ARRAY_COUNT(drawProc); ++j) {
            canvas->save();
            for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
                drawProc[j](canvas, r, filters[i]);
                canvas->translate(0, DY);
            }
            canvas->restore();
            canvas->translate(DX, 0);
        }

        for(size_t j = 0; j < SK_ARRAY_COUNT(filters); ++j) {
            SkSafeUnref(filters[j]);
        }
    }

void QxrdImagePlot::setProcessor(QxrdDataProcessorWPtr proc)
{
  m_DataProcessor = proc;

  QxrdDataProcessorPtr dp(m_DataProcessor);

  if (dp) {
    QxrdCenterFinderPtr cf(dp->centerFinder());

    if (cf) {
      connect(m_CenterFinderPicker, SIGNAL(selected(QPointF)),
              cf.data(), SLOT(onCenterChanged(QPointF)));

      connect(m_Circles, SIGNAL(selected(QRectF)),
              dp.data(), SLOT(maskCircle(QRectF)));

      connect(m_Polygons, SIGNAL(selected(QVector<QPointF>)),
              dp.data(), SLOT(maskPolygon(QVector<QPointF>)));

      connect(m_Measurer, SIGNAL(selected(QVector<QPointF>)),
              dp.data(), SLOT(measurePolygon(QVector<QPointF>)));

      //  connect(m_Slicer, SIGNAL(selected(QVector<QPointF>)),
    //          m_DataProcessor, SLOT(slicePolygon(QVector<QPointF>)));

      connect(m_PowderPointPicker, SIGNAL(selected(QPointF)),
              cf.data(), SLOT(onPointSelected(QPointF)));

      onCenterChanged(QPointF(cf->get_CenterX(), cf->get_CenterY()));

      connect(cf->prop_MarkedPoints(), SIGNAL(valueChanged(QxrdPowderPointVector,int)),
              this, SLOT(onMarkedPointsChanged()));

      onMarkedPointsChanged();
    }
  }

  connect(m_Slicer, SIGNAL(selected(QVector<QPointF>)),
          this, SIGNAL(slicePolygon(QVector<QPointF>)));

  connect(m_HistogramSelector, SIGNAL(selected(QRectF)),
          this, SIGNAL(selectHistogram(QRectF)));
}

void testMNISTConvolutionalNeuralNetworkDriver()
{
  MNISTDataFunction mnistdf;
  Config config;
  updateMNISTConfig(config);
  config.setValue("addBiasTerm", false);
  config.setValue("meanStddNormalize", false);
  SGDOptimizer sgd;

  const int imageDim = 28; // height/width of image
  const int filterDim = 9; // dimension of convolutional filter
  const int numFilters = 20; // number of convolutional filters
  const int poolDim = 2; // dimension of pooling area
  const int numClasses = 10; // number of classes to predict

  ConvolutionalNeuralNetworkCostFunction cf(imageDim, filterDim, numFilters, poolDim, numClasses);
  Driver drv(&config, &mnistdf, &cf, &sgd);
  drv.drive();
}

   /// <summary>Called when user selects a text colour.</summary>
   void LanguageEditView::OnCommandSelectColour()
   {
      CharFormat cf(CFM_COLOR, 0);

      // DEBUG:
      //Console << HERE << ENDL;

      // Get selected colour
      if (ColourMenu)
         if (auto dlg = (CMFCColorBar*)ColourMenu->GetMenuBar())
            cf.crTextColor = (dlg->GetColor() != -1 ? dlg->GetColor() : (COLORREF)RichTextColour::Default);

      // Highlight text
      RichEdit.SetSelectionCharFormat(cf);
      ColourMenu->CloseMenu();

      // Modify document
      GetDocument()->SetModifiedFlag(TRUE);
   }

GameInfo::GameInfo(string filename)
{
	ConfigFile cf(filename);

	display_X_Res = cf.Value("Display Settings", "displayWidth");
	display_Y_Res = cf.Value("Display Settings", "displayHeight");
	render_X_Res_ = cf.Value("Display Settings", "renderWidth");
	render_Y_Res_ = cf.Value("Display Settings", "renderHeight");
	fps = cf.Value("Display Settings", "fps");
	pollrate_ = cf.Value("Display Settings", "pollrate");
	viewWidth = cf.Value("Display Settings", "viewWidth");
	viewHeight = cf.Value("Display Settings", "viewHeight");

	viewWidth *= cf.Value("Display Settings", "viewScalar", 1.0);
	viewHeight *= cf.Value("Display Settings", "viewScalar", 1.0);

	string tempPath = cf.Value("Misc Settings", "defaultFont");
	if (!defaultFont_.loadFromFile(tempPath)) std::cout << "couldn't load font" << std::endl;
	tempPath = cf.Value("Misc Settings", "uiSheet");
	if (!UITex.loadFromFile(tempPath))std::cout << "couldn't load uiTex" << std::endl;
}

struct coord *
cf_rel (coord_f cf, struct frame *f, struct coord *c, int dx, int dy)
{
  int dir;

  if (cf == _mf || cf == _tf || cf == _bf)
    dir = (f->dir == LEFT) ? -1 : +1;
  else if (cf == _mba || cf == _tb || cf == _bb)
    dir = (f->dir == LEFT) ? +1 : -1;
  else if (cf == _ml || cf == _tl || cf == _bl)
    dir = -1;
  else if (cf == _mr || cf == _tr || cf == _br)
    dir = +1;
  else assert (false);

  cf (f, c);
  c->x += dir * dx;
  c->y += dy;

  return c;
}

void process_package_cmds_cfg( Plib::Package* pkg )
{
  // ConfigFile cf( (pkg->dir() + "cmds.cfg").c_str(), "Commands" );
  Clib::ConfigFile cf( GetPackageCfgPath( pkg, "cmds.cfg" ).c_str(), "Commands" );
  Clib::ConfigElem elem;
  while ( cf.read( elem ) )
  {
    CmdLevel* cmdlevel = find_cmdlevel( elem.rest() );
    if ( !cmdlevel )
    {
      elem.throw_error( std::string( "Command Level " ) + elem.rest() + " not found." );
    }

    std::string tmp;
    while ( elem.remove_prop( "DIR", &tmp ) )
    {
      Clib::mklower( tmp );
      cmdlevel->add_searchdir_front( pkg, Clib::normalized_dir_form( pkg->dir() + tmp ) );
    }
  }
}

void read_resources_dat()
{
  std::string resourcefile = Plib::systemstate.config.world_data_path + "resource.dat";

  if ( Clib::FileExists( resourcefile ) )
  {
    Clib::ConfigFile cf( resourcefile, "GLOBALRESOURCEPOOL REGIONALRESOURCEPOOL" );
    Clib::ConfigElem elem;
    while ( cf.read( elem ) )
    {
      if ( elem.type_is( "GlobalResourcePool" ) )
      {
        read_global_data( elem );
      }
      else
      {
        read_region_data( elem );
      }
    }
  }
}

void main ()
{
	int a[3] = {0,0,0};
	int arr[100];
	int i;
	int j;
	int sum;
	int cf ( int, int );
	for ( i = 0; i < 100; i++ )
		arr[i] = cf ( i+1, 3 );

//	for ( i = 0; i < 100; i++ )
//		cout<<i+1<<" "<<arr[i]<<endl;
	int n;
	cin>>n;
	for ( i = 1; i <= n; i++ )
	{
		a[0] = 1;
		a[1] = 1;
		a[2] = 1;
		while ( a[0] < i )
		{
			sum = arr[a[0]] + arr[a[1]] + arr[a[2]];
			if ( sum == arr[i-1] && a[0] <= a[1] && a[1] <= a[2])
				cout<<"Cube = "<<i<<", Triple = ("<<a[0] +1<<','<<a[1] + 1<<','<<a[2] + 1<<')'<<endl;
			a[2]++;
			j = 2;
			while ( a[j] == i )
			{
				a[j] = 0;
				j--;
				a[j]++;
				if ( a[0] == i )
					break;
			}
		
		}
	}

}

void VisualDebugger::onPvdConnected( PVD::PvdConnection* inFactory )
{
	PVD::PvdConnection* cf( inFactory );
	if(!cf)
		return;

	if(mPvdConnection && mPvdConnectionFactory)
		disconnect();

	mPvdConnectionFactory = cf;
	mPvdConnection = mPvdConnectionFactory->createDataStream();
	if(!mPvdConnection)
		return;

	mPvdConnectionFactory->addRef();
	mPvdConnection->addRef();
	mPvdConnection->setNamespace( getPhysxNamespace() );
	updateScenesPvdConnection();

	sendClassDescriptions();
	sendEntireSDK();
}

int main(int argc, char** argv) {
  try {
    RMF_ADD_INPUT_FILE("rmf");
    RMF_ADD_OUTPUT_FILE("pdb");
    RMF_ADD_FRAMES;
    process_options(argc, argv);

    RMF::FileConstHandle rh = RMF::open_rmf_file_read_only(input);
    std::ostream* out;
    std::ofstream fout;
    if (!output.empty()) {
      fout.open(output.c_str());
      if (!fout) {
        std::cerr << "Error opening file " << output << std::endl;
        return 1;
      }
      out = &fout;
    } else {
      out = &std::cout;
    }
    RMF::decorator::IntermediateParticleFactory ipf(rh);
    RMF::decorator::AtomFactory af(rh);
    RMF::decorator::ChainFactory cf(rh);
    RMF::decorator::ResidueFactory rf(rh);
    RMF::NodeConstHandle rn = rh.get_root_node();
    for (unsigned int input_frame = start_frame, output_frame = 0;
         input_frame < rh.get_number_of_frames();
         input_frame += step_frame, ++output_frame) {
      rh.set_current_frame(RMF::FrameID(input_frame));
      *out << (boost::format("MODEL%1$9d") % (output_frame + 1)) << std::endl;
      write_atoms(*out, 0, rn, ipf, af, cf, rf);
      *out << "ENDMDL" << output_frame + 1 << std::endl;
    }
    return 0;
  }
  catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
  }
}

void test_sort(size_t sz)
{
	unsigned i, a;
	int s1=0, s2=0, x1=0, x2=0;
	list_t* l;
	list_node_t* n;

	printf("test_sort(%d) ... ", sz);

	l = list_create();

	for (i = 0; i < sz; i++) {
		a = rnd() % 100;
		if (i % 2)
			list_append(l, (void*)a);
		else
			list_prepend(l, (void*)a);
		s1 += a;
		x1 ^= a;
	}

	list_sort(list_reverse(l), cf);

	for (i = 0, n = l->first; n != NULL; i++, n = n->next) {
		if (n->next)
			assert(cf(n->data, n->next->data) <= 0);

		s2 += (unsigned)n->data;
		x2 ^= (unsigned)n->data;
	}

	assert(s1 == s2);
	assert(x1 == x2);
	assert(i == l->len);

	list_destroy(l);

	printf("ok\n");
}

TEST(CallframeTestSuite, AddSingleFrame)
{
	Callframe cf(0xffffffff80cba260UL, "/boot/kernel/kernel");

	cf.addFrame("netinet/tcp_input.c", "tcp_input", "tcp_input",
		3015, 2693, 0xa45d2);

	ASSERT_TRUE(!cf.isUnmapped());

	const auto & frames = cf.getInlineFrames();
	ASSERT_EQ(frames.size(), 1);

	const auto & fr = frames.at(0);
	ASSERT_EQ(fr.getFile(), "netinet/tcp_input.c");
	ASSERT_EQ(fr.getFunc(), "tcp_input");
	ASSERT_EQ(fr.getDemangled(), "tcp_input");
	ASSERT_EQ(fr.getCodeLine(), 3015);
	ASSERT_EQ(fr.getFuncLine(), 2693);
	ASSERT_EQ(fr.getDieOffset(), 0xa45d2);
	ASSERT_EQ(fr.getOffset(), 0xffffffff80cba260UL);
	ASSERT_TRUE(fr.isMapped());
}

void TestListCounter::TestCreateListText()
{
	RTFfile theFile(new RTFFileContext);
	AutoDocFileReaderImpl4Tests reader(GET_TEST_FILE_PATH(_T("list_outline.doc")), &theFile);
	reader.Initialize();

	ListCounter lc(&theFile, 9, -1); // pick up the list for \ls9

	lc.StepLevel(9,0);
	RTFpn* pPn = lc.CreateListText(0);
	assertTest(pPn!=NULL);
	assertTest(pPn->GetCount()>0);

	RTFformatting form(theFile.GetFileContext());
	form.the_RTFpn = pPn;
	RTFchrfmt cf(theFile.GetFileContext());
	CWideString cws;
	assertTest (form.GetListNumber(&theFile, cws, cf));
	assertTest(cws == L"I.\t");


}

void read_resource_cfg( const char* resource )
{
  std::string filename = std::string( "regions/" ) + resource + std::string( ".cfg" );
  Clib::ConfigFile cf( filename.c_str(), "GLOBAL REGION" );
  Clib::ConfigElem elem;

  std::unique_ptr<ResourceDef> rd( new ResourceDef( resource ) );

  while ( cf.read( elem ) )
  {
    if ( elem.type_is( "global" ) )
    {
      rd->read_config( elem );
    }
    else
    {
      rd->read_region( elem );
    }
  }

  gamestate.resourcedefs[resource] = rd.release();
}

bool CompositeCutter::vertexPush(const Fiber& f, Interval& i, const Triangle& t) const {
    bool result = false;
    std::vector< std::pair<double, CCPoint> > contacts;
    for (unsigned int n=0; n<cutter.size(); ++n) {
        Interval ci;
        Fiber cf(f);
        cf.p1.z = f.p1.z + zoffset[n];
        cf.p2.z = f.p2.z + zoffset[n]; // raised/lowered fiber to push along
        if ( cutter[n]->vertexPush(cf,ci,t) ) {
            if ( ccValidHeight( n, ci.upper_cc, f ) )
                contacts.push_back( std::pair<double,CCPoint>(ci.upper, ci.upper_cc) );
            if ( ccValidHeight( n, ci.lower_cc, f ) )
                contacts.push_back( std::pair<double,CCPoint>(ci.lower, ci.lower_cc) );
        }
    }
    
    for( unsigned int n=0; n<contacts.size(); ++n ) {
        i.update( contacts[n].first, contacts[n].second );
        result = true;
    }
    return result;
}

void load_stacking_cfg()
{
  std::string main_cfg = "config/stacking.cfg";

  if ( Clib::FileExists( main_cfg.c_str() ) )
  {
    Clib::ConfigFile cf_main( main_cfg.c_str() );
    read_stacking_cfg( cf_main );
  }
  for ( Plib::Packages::iterator itr = Plib::systemstate.packages.begin();
        itr != Plib::systemstate.packages.end(); ++itr )
  {
    Plib::Package* pkg = ( *itr );
    // string filename = pkg->dir() + cfgname + ".cfg";
    std::string filename = Plib::GetPackageCfgPath( pkg, "stacking.cfg" );
    if ( Clib::FileExists( filename.c_str() ) )
    {
      Clib::ConfigFile cf( filename.c_str() );
      read_stacking_cfg( cf );
    }
  }
}

/*********************************************************************
 *		_lfind_s ([email protected])
 */
void* CDECL _lfind_s(const void* match, const void* start,
                   unsigned int* array_size, unsigned int elem_size,
                   int (CDECL *cf)(void*,const void*,const void*),
                   void* context)
{
  unsigned int size;
  if (!MSVCRT_CHECK_PMT(match != NULL)) return NULL;
  if (!MSVCRT_CHECK_PMT(array_size != NULL)) return NULL;
  if (!MSVCRT_CHECK_PMT(start != NULL || *array_size == 0)) return NULL;
  if (!MSVCRT_CHECK_PMT(cf != NULL)) return NULL;
  if (!MSVCRT_CHECK_PMT(elem_size != 0)) return NULL;

  size = *array_size;
  if (size)
    do
    {
      if (cf(context, match, start) == 0)
        return (void *)start; /* found */
      start = (const char *)start + elem_size;
    } while (--size);
  return NULL;
}

void load_resource_cfg()
{
  if ( !Clib::FileExists( "regions/resource.cfg" ) )
  {
    if ( Plib::systemstate.config.loglevel > 1 )
      INFO_PRINT << "File regions/resource.cfg not found, skipping.\n";
    return;
  }

  Clib::ConfigFile cf( "regions/resource.cfg", "ResourceSystem" );
  Clib::ConfigElem elem;
  while ( cf.read( elem ) )
  {
    std::string resourcename;
    while ( elem.remove_prop( "ResourceType", &resourcename ) )
    {
      read_resource_cfg( resourcename.c_str() );
    }
  }
  if ( Plib::systemstate.config.count_resource_tiles )
    count_resource_tiles();
}