private void btnPrint_Click(object sender, EventArgs e)
{
    //create Printer FlexChart
    ChartPrinter chartPrinter = new ChartPrinter(flexChart1, true);

    //set settings for page
    if (PageSettngs == null)
        PageSettngs = new PageSettings() { Landscape = true };

    //replace default page settings with custom page settings
    chartPrinter.PageSettingsProp = PageSettngs;

    //replace default printer settings with custom printer settings, if any
    if (PrinterSettngs != null)
    {
        chartPrinter.PrintSettingsProp = PrinterSettngs;
    }

    //set whether or not to resize FlexChart according to the print rectangle
    ChartPrinter.PrintScale pscale =
        (ChartPrinter.PrintScale)Enum.Parse(typeof(ChartPrinter.PrintScale), "None");

    //set whether to print in GrayScale or not
    chartPrinter.UseGrayScale = false;

    bool usePrintPreview = true;
    bool printAsBitmap = false;

    //print FlexChart with specific printer and page settings
    chartPrinter.PrintCtrl(pscale, new Rectangle(100,200,400,400), PageSettngs, printAsBitmap, usePrintPreview);
}

private void btnSubCharts_Click(object sender, EventArgs e)
{
    if (PageSettngs == null)
       PageSettngs = new PageSettings { Landscape = true };

    PrintDocument pd = new PrintDocument();
    pd.DefaultPageSettings = PageSettngs;
    pd.PrinterSettings = PrinterSettngs;

    int pageNumber = 0;

    // determine the limits over which the chart should be printed.
    int pageCount = 4;
    double minXValue = 0;
    double maxXValue = ShowAxisY.AxisX.ActualMax;

    double increment = (maxXValue - minXValue) / pageCount;

    double minFlex = double.NaN, maxFlex = double.NaN;
    double minFlexY = double.NaN, maxFlexY = double.NaN;
    int bitmapLeft = 0;

    pd.BeginPrint += (pageSender, beginPrintEventArgs) =>
    {
         if(ShowAxis)
         {
              // save the current axis limits
              minFlex = ShowAxisY.AxisX.Min;
              maxFlex = ShowAxisY.AxisX.Max;
              minFlexY = ShowAxisY.AxisY.Min;
              maxFlexY = ShowAxisY.AxisY.Max;

              ShowAxisY.AxisX.Min = minXValue;
              ShowAxisY.AxisX.Max = increment;
              ShowAxisY.AxisY.Min = ShowAxisY.AxisY.ActualMin;
              ShowAxisY.AxisY.Max = ShowAxisY.AxisY.ActualMax;
         }              
         else
         {
              bitmapLeft = 0;
         }
        pageNumber = 0;
    };

    pd.PrintPage += (pageSender, printPageEventArgs) =>
    {
         pageNumber++;

         if (ShowAxis)
         {
              // Each chart or page could use a different FlexChart instance, but in this case
              // subsets of a single FlexChart instance is used.
              ChartPrinter chartPrinter = new ChartPrinter(ShowAxisY, true);

              // The chart is drawn within the rectangle assuming coordinates relative
              // to the Top-Left page margin as specified in the prinPageEventArgs.
              // An empty rectangle indicates a full page rather than a limited
              // rectangle on the page.
              Rectangle rect = new Rectangle(0, 0, 0, 0);

              printPageEventArgs.HasMorePages = pageNumber < 30;       // sanity check to avoid endless loop.
              chartPrinter.PrinterCtrlToPage(pd, printPageEventArgs, ChartPrinter.PrintScale.Fit, rect, false);
         }
         else
         {
              int pageWidth = PageSettngs.Bounds.Width - PageSettngs.Margins.Left - PageSettngs.Margins.Right;
              int pageHeight = PageSettngs.Bounds.Height - PageSettngs.Margins.Top - PageSettngs.Margins.Bottom;
              int bitMapWidth = pageCount * pageWidth;
              int bitMapHeight = pageHeight;
              int incremnt = bitMapWidth / pageCount;
              Bitmap bitmap = new Bitmap(bitMapWidth, bitMapHeight);
              using (Graphics gr = Graphics.FromImage(bitmap))
              {
                   this.ShowAxisY.DrawChart(gr, new Size(bitMapWidth, bitMapHeight));
              }
              Graphics g = printPageEventArgs.Graphics;
              g.DrawImage(bitmap,
                  new Rectangle(PageSettngs.Margins.Left, PageSettngs.Margins.Top, incremnt, bitMapHeight),
                  new Rectangle(bitmapLeft, 0, incremnt, bitMapHeight),
                  GraphicsUnit.Pixel);

              bitmapLeft += incremnt;
         }
         if(ShowAxis)
         {
              bool morePages = ShowAxisY.AxisX.Max < maxXValue;
              printPageEventArgs.HasMorePages = morePages;
              if (morePages)
              {
                   // set up for the next page.
                   ShowAxisY.AxisX.Min += increment;
                   ShowAxisY.AxisX.Max += increment;
              }
         }
         else
         {
              bool morepages = pageNumber < 8;
              printPageEventArgs.HasMorePages = morepages;
         }
    };

    pd.EndPrint += (pageSender, endPrintEventArgs) =>
    {
         if(ShowAxis)
         {
              // restore the axis limits
              ShowAxisY.AxisX.Max = maxFlex;
              ShowAxisY.AxisX.Min = minFlex;
              ShowAxisY.AxisY.Max = maxFlexY;
              ShowAxisY.AxisY.Min = minFlexY;
         }
         else
         {
              bitmapLeft = 0;
         }
        // reset for next print from preview dialog.
        pageNumber = 0;
    };

    ChartPrinter.ChartPreviewDialogEx(pd, true);
    pd.Dispose();
}