开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
glprintView.cpp
资源名称：opengl_printing_demo.zip　[点击查看]
上传用户：donsun
上传日期：2022-08-10
资源大小：36k
文件大小：13k
源码类别：

OpenGL

开发平台：

Visual C++

glprintView.cpp：源码内容
  1. // glprintView.cpp : implementation of the CGlprintView class
  2. //
  4. #include "stdafx.h"
  5. #include "glprint.h"
  7. #include "glprintDoc.h"
  8. #include "glprintView.h"
  9. #include <glglaux.h>
  11. #ifdef _DEBUG
  12. #define new DEBUG_NEW
  13. #undef THIS_FILE
  14. static char THIS_FILE[] = __FILE__;
  15. #endif
  17. /////////////////////////////////////////////////////////////////////////////
  18. // CGlprintView
  20. IMPLEMENT_DYNCREATE(CGlprintView, CView)
  22. BEGIN_MESSAGE_MAP(CGlprintView, CView)
  23. //{{AFX_MSG_MAP(CGlprintView)
  24. ON_WM_CREATE()
  25. ON_WM_DESTROY()
  26. ON_WM_SIZE()
  27. ON_COMMAND(ID_FILE_SAVE, OnFileSave)
  28. ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
  29. //}}AFX_MSG_MAP
  30. // Standard printing commands
  31. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  32. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  33. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  34. END_MESSAGE_MAP()
  36. /////////////////////////////////////////////////////////////////////////////
  37. // CGlprintView construction/destruction
  39. CGlprintView::CGlprintView()
  40. {
  41. // TODO: add construction code here
  43. }
  45. CGlprintView::~CGlprintView()
  46. {
  47. }
  49. BOOL CGlprintView::PreCreateWindow(CREATESTRUCT& cs)
  50. {
  51. // TODO: Modify the Window class or styles here by modifying
  52. //  the CREATESTRUCT cs
  54. return CView::PreCreateWindow(cs);
  55. }
  57. /////////////////////////////////////////////////////////////////////////////
  58. // CGlprintView drawing
  59. void CGlprintView::OnDraw(CDC* pDC)
  60. {
  61. CGlprintDoc* pDoc = GetDocument();
  62. ASSERT_VALID(pDoc);
  64. // TODO: add draw code for native data here
  65. //if print
  66. if(pDC->IsPrinting())
  67. {
  68.  //draw the image in memory DC to print DC 
  69.  CRect      drawRect;
  70.  int        cx, cy;
  71.  COLORREF clrOld = pDC->SetTextColor(RGB(250, 10, 10));
  72.  pDC->TextOut(450,10, "This is a demo of OpenGL print provided by Zhaohui Xing");
  73.  pDC->SetTextColor(RGB(128, 128, 255));
  74.  pDC->TextOut(40,80, "Large Size");
  75.  drawRect.SetRect(40, 160, 2440, 1960);
  76.          pDC->DPtoLP(&drawRect);
  77.  m_MemImageDC.CopyDataToDC(pDC, drawRect);
  78.  pDC->TextOut(40,1960, "Medium Size");
  79.  drawRect.SetRect(500, 2040, 2100, 3240);
  80.          pDC->DPtoLP(&drawRect);
  81.  m_MemImageDC.CopyDataToDC(pDC, drawRect);
  82.  pDC->TextOut(40,3260, "Orignal Size");
  83.  m_MemImageDC.GetMemorySize(&cx, &cy);
  84.  drawRect.SetRect(1000, 3400, 1000 + cx , 3400 + cy);
  85.          pDC->DPtoLP(&drawRect);
  86.  m_MemImageDC.CopyDataToDC(pDC, drawRect);
  87.  pDC->SetTextColor(clrOld);
  88. }
  89. else //draw opnGL in current DC
  90. {
  91.      CPalette* oldPalette;
  93.          //Set logic palette
  94.      oldPalette = m_pDC->SelectPalette(&m_Palette, FALSE);
  95.      m_pDC->RealizePalette();
  97.  //draw openGL object
  98.      wglMakeCurrent(m_pDC->GetSafeHdc(), m_hRC);
  99.      DrawObject();
  100.      SwapBuffers(m_pDC->GetSafeHdc());
  101.          wglMakeCurrent(m_pDC->GetSafeHdc(), NULL);
  102.  
  103.     //Prepare the memory DC 
  104.  CRect rect;
  105.  GetClientRect(&rect);
  106.      m_MemImageDC.SetMemorySize(rect.Width(), rect.Height());
  107.  //copy the image data in current DC to memory
  108.  m_MemImageDC.CopyDataFromDC(m_pDC, rect);
  110.      m_pDC->SelectPalette(oldPalette, FALSE);
  111. }      
  112. }
  114. /////////////////////////////////////////////////////////////////////////////
  115. // CGlprintView printing
  117. BOOL CGlprintView::OnPreparePrinting(CPrintInfo* pInfo)
  118. {
  119. // default preparation
  120. return DoPreparePrinting(pInfo);
  121. }
  123. void CGlprintView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  124. {
  125. // TODO: add extra initialization before printing
  126. }
  128. void CGlprintView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  129. {
  130. // TODO: add cleanup after printing
  131. }
  133. /////////////////////////////////////////////////////////////////////////////
  134. // CGlprintView diagnostics
  136. #ifdef _DEBUG
  137. void CGlprintView::AssertValid() const
  138. {
  139. CView::AssertValid();
  140. }
  142. void CGlprintView::Dump(CDumpContext& dc) const
  143. {
  144. CView::Dump(dc);
  145. }
  147. CGlprintDoc* CGlprintView::GetDocument() // non-debug version is inline
  148. {
  149. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGlprintDoc)));
  150. return (CGlprintDoc*)m_pDocument;
  151. }
  152. #endif //_DEBUG
  154. /////////////////////////////////////////////////////////////////////////////
  155. // CGlprintView message handlers
  157. /********************************************************************/
  158. /* Set up the OpenGL display environment                      */
  159. /********************************************************************/
  160. int CGlprintView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  161. {
  162. if (CView::OnCreate(lpCreateStruct) == -1)
  163. return -1;
  165. // TODO: Add your specialized creation code here
  166. PIXELFORMATDESCRIPTOR pfd =
  167. {
  168. sizeof(PIXELFORMATDESCRIPTOR),
  169. 1,
  170. PFD_DRAW_TO_WINDOW|
  171. PFD_SUPPORT_OPENGL|
  172. PFD_DOUBLEBUFFER,  
  173. PFD_TYPE_RGBA,
  174. 24,
  175. 0,0,0,0,0,0,
  176.         0,0,0,0,0,0,0,
  177. 32,
  178. 0,0,
  179. PFD_MAIN_PLANE,
  180. 0,
  181. 0,0,0
  182. };
  183.      
  184.     m_pDC = new CClientDC(this);
  185. int pixelFormat =
  186. ChoosePixelFormat(m_pDC->GetSafeHdc(), &pfd);
  187. BOOL success = 
  188. SetPixelFormat(m_pDC->GetSafeHdc(), pixelFormat, &pfd);
  190. DescribePixelFormat(m_pDC->GetSafeHdc(), pixelFormat,
  191.   sizeof(pfd), &pfd);
  193. if(pfd.dwFlags & PFD_NEED_PALETTE)
  194.          SetPalette();
  196. m_hRC = wglCreateContext(m_pDC->GetSafeHdc());
  197. wglMakeCurrent(m_pDC->m_hDC,m_hRC);
  199. Initialize();
  201. wglMakeCurrent(NULL,NULL);
  203. return 0;
  204. }
  206. /********************************************************************/
  207. /* Celan all memory allocated to OpenGL resource                */
  208. /********************************************************************/
  209. void CGlprintView::OnDestroy() 
  210. {
  211. CView::OnDestroy();
  213. // TODO: Add your message handler code here
  214. wglDeleteContext(m_hRC);
  215.     m_Palette.DeleteObject();
  216. ReleaseDC(m_pDC);
  217. }
  220. /********************************************************************/
  221. /* If the window size change, adjust the view point for the correct */
  222. /* OpenGL diplay                                                    */
  223. /********************************************************************/
  224. void CGlprintView::OnSize(UINT nType, int cx, int cy) 
  225. {
  226. CView::OnSize(nType, cx, cy);
  228. // TODO: Add your message handler code here
  229.     CClientDC clientDC(this);
  230. wglMakeCurrent(clientDC.m_hDC, m_hRC);
  231. glMatrixMode(GL_PROJECTION);
  232. glLoadIdentity();
  233. glFrustum(-1.0, 1.0, -1.0, 1.0, 2.0, 7.0);
  234. glViewport(0, 0, cx, cy);
  235. wglMakeCurrent(NULL, NULL);
  237. }
  240. /********************************************************************/
  241. /* Set up the palette for OpenGL display DC                         */
  242. /********************************************************************/
  243. void CGlprintView::SetPalette(void)
  244. {
  245. PIXELFORMATDESCRIPTOR pfd;  // Pixel Format Descriptor         
  246. LOGPALETTE *pPal; // Pointer to memory for logical palette
  247. int PixelFormat; // Pixel format index
  248.     int paletteSize;            // Number of entries in palette 
  249. BYTE RedMask;               // Range for each color entry (7,7,and 3)
  250. BYTE GreenMask;
  251. BYTE BlueMask;
  252.     HDC hDC = GetDC()->GetSafeHdc();  //the context device 
  254. // Get the pixel format index and retrieve the pixel format description
  255.     PixelFormat = GetPixelFormat(hDC);
  256.     DescribePixelFormat(hDC, PixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
  257.     
  259. // Check whether the pixel format and the pixel type
  260. if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
  261.   pfd.iPixelType == PFD_TYPE_COLORINDEX))
  262.     return;
  264. // Get the number of entries in palette. 256 colors for 8 bits 
  265.     paletteSize = 1 << pfd.cColorBits;
  266.     
  267. // Allocate for the logical palette
  268. pPal = (LOGPALETTE*)
  269. malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
  270.     
  272. // Fill the logical palette header information 
  273. pPal->palVersion = 0x300;            //support Windows3.0
  274.     pPal->palNumEntries = paletteSize;   //number of colors entries
  276.     // Set the 1st entries of logical palette with the current system palette 
  277.     (void) GetSystemPaletteEntries(hDC, 0, paletteSize, &pPal->palPalEntry[0]);
  279. //Set the RGB mask
  280. RedMask = (1 << pfd.cRedBits) - 1;
  281. GreenMask = (1 << pfd.cGreenBits) - 1;
  282. BlueMask = (1 << pfd.cBlueBits) - 1;
  284. //Set all entries of the logical palette 
  285.     for (int i=0; i<paletteSize; ++i) 
  286. {
  287.     pPal->palPalEntry[i].peRed =
  288.     (((i >> pfd.cRedShift) & RedMask) * 255) / RedMask;
  289.     pPal->palPalEntry[i].peGreen =
  290.     (((i >> pfd.cGreenShift) & GreenMask) * 255) / GreenMask;
  291.     pPal->palPalEntry[i].peBlue =
  292.     (((i >> pfd.cBlueShift) & BlueMask) * 255) / BlueMask;
  293.     pPal->palPalEntry[i].peFlags = 0;
  294.     }
  296. //Create the palette
  297.     m_Palette.CreatePalette(pPal);
  299. //Free the memory allocated for the logical palette 
  300.     free(pPal);
  301. }
  304. /********************************************************************/
  305. /* Initialize the light setting                                   */
  306. /********************************************************************/
  307. void CGlprintView::Initialize(void)
  308. {
  309. float fv[4];
  311. fv[0] = 0.3f;
  312. fv[1] = 0.3f;
  313. fv[2] = 0.3f;
  314. fv[3] = 1.0f;
  315. glLightfv(GL_LIGHT0, GL_AMBIENT, fv);//set light ambient
  318. fv[0] = 0.1f;
  319. fv[1] = 0.1f;
  320. fv[2] = 0.1f;
  321. fv[3] = 1.0f;
  322. glLightfv(GL_LIGHT0, GL_DIFFUSE, fv);//set light specular
  324. fv[0] = 0.3f;
  325. fv[1] = 0.3f;
  326. fv[2] = 0.1f;
  327. fv[3] = 1.0f;
  328. glLightfv(GL_LIGHT0, GL_SPECULAR, fv);//set light specular
  330. fv[0] = 100.0f;
  331. fv[1] = 0.0f;
  332. fv[2] = 0.0f;
  333. fv[3] = 0.0f;
  334. glLightfv(GL_LIGHT0, GL_POSITION, fv);//set light position
  336. glEnable(GL_LIGHTING);
  337.     glEnable(GL_LIGHT0);
  338. }
  341. /********************************************************************/
  342. /* Display the OpenGL object                                      */
  343. /********************************************************************/
  344. void CGlprintView::DrawObject(void)
  345. {
  346. float fv[4];
  347. float shine;
  349. glShadeModel(GL_SMOOTH);
  350. glEnable(GL_DEPTH_TEST);
  352. //clear color buffer
  353. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  354. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  357.     glMatrixMode(GL_MODELVIEW);
  358.     glLoadIdentity();
  360. glPushMatrix();
  362. shine = 0.3f;
  363. glMaterialf(GL_FRONT, GL_SHININESS, shine);//set specular
  365. fv[0] = 0.4f;
  366. fv[1] = 0.4f;
  367. fv[2] = 0.4f;
  368. fv[3] = 0.1f;
  369. glMaterialfv(GL_FRONT, GL_SPECULAR, fv);//set specular
  370. glMaterialfv(GL_FRONT, GL_EMISSION, fv);//set specular
  372. //draw the wireframe sphere
  373. fv[0] = 0.0f;
  374. fv[1] = 0.0f;
  375. fv[2] = 0.4f;
  376. fv[3] = 1.0f;
  377. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, fv);//set material
  378. glTranslatef(0.0f, 0.0f, -6.0f);
  379.     glRotated(45, 1.0, 0.0, 0.0);     
  380.     glRotated(-30, 0.0, 1.0, 0.0);     
  381.     glRotated(60, 0.0, 0.0, 1.0);     
  382.     auxWireSphere(1.0);
  384. //draw the solid cylinder
  385. fv[0] = 0.1f;
  386. fv[1] = 0.4f;
  387. fv[2] = 0.1f;
  388. fv[3] = 10.0f;
  389. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, fv);//set material
  390. glTranslatef(0.0f, 0.5f, 0.0f);
  391. auxSolidCylinder(0.1, 3.0);
  392. glTranslatef(0.0f, -0.5f, 0.0f);
  394. //draw the solid arrow
  395. fv[0] = 0.9f;
  396. fv[1] = 0.1f;
  397. fv[2] = 0.1f;
  398. fv[3] = 10.2f;
  399. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, fv);//set material
  400. glTranslatef(0.0f, 1.5f, 0.0f);
  401.     glRotated(-90, 1.0, 0.0, 0.0);     
  402.     auxSolidCone(0.4, 0.8);
  403.     glRotated(90, 1.0, 0.0, 0.0);     
  404. glTranslatef(0.0f, -1.5f, 0.0f);
  406.     glRotated(-60, 0.0, 0.0, 1.0);     
  407.     glRotated(30, 0.0, 1.0, 0.0);     
  408.     glRotated(-45, 1.0, 0.0, 0.0);     
  409. glTranslatef(0.0f, 0.0f, 6.0f);
  410.    
  411. glPopMatrix();
  413. glFlush();
  415. }
  418. /********************************************************************/
  419. /* Save current OpenGL image to DIB file                                      */
  420. /********************************************************************/
  421. void CGlprintView::OnFileSave() 
  422. {
  423. // TODO: Add your command handler code here
  424. //Set up file dialog setting
  425. char FileString[] = "DIB File(*.bmp)*.bmp";
  427. CFileDialog dlg(FALSE,NULL,NULL,OFN_CREATEPROMPT|OFN_OVERWRITEPROMPT,NULL,NULL);
  428. dlg.m_ofn.lpstrFilter = (LPSTR)FileString;
  429.     dlg.m_ofn.lpstrTitle = "Save DIB File";
  430. if(dlg.DoModal()==IDOK)
  431. {
  432. //Get file name
  433. CString filename = dlg.GetFileTitle();
  434. filename += ".";
  435. CString fileext;
  436. fileext = dlg.GetFileExt(); 
  437. if(fileext.IsEmpty())
  438. filename += "bmp";
  439. else
  440. filename += fileext;
  442. //Write image data to disk file
  443. CFile file;
  444. CFileException fileexc;
  445. file.Open(filename,CFile::modeCreate|CFile::modeWrite,&fileexc);
  446. m_MemImageDC.WriteDataToDIBfile(&file);
  447. file.Close();
  448. }
  450. }
  452. /********************************************************************/
  453. /* Save current OpenGL image to DIB file                                      */
  454. /********************************************************************/
  455. void CGlprintView::OnFileSaveAs() 
  456. {
  457. // TODO: Add your command handler code here
  458. OnFileSave();
  459. }