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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
MapHelper.cpp
资源名称：MoLecture.rar　[点击查看]
上传用户：qinfarui
上传日期：2022-08-10
资源大小：362k
文件大小：22k
源码类别：

GIS编程

开发平台：

Visual C++

MapHelper.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////////
  2. // MapHelper.cpp - Utility routines for working with the MapObjects control
  3. // 
  5. #include "stdafx.h"
  6. #include <math.h>
  7. #include <afxctl.h>
  8. #include "maphelper.h"
  11. ///////////////////////////////////////////////////////////////////////////
  12. // Data Directory
  13. //
  14. CDataDir::CDataDir()
  15. : m_path("..\..\data")
  16. {
  17. }
  19. CString CDataDir::GetPath()
  20. {
  21. return m_path;
  22. }
  24. void CDataDir::SetPath(LPCTSTR newPath)
  25. {
  26. m_path = newPath;
  27. }
  30. ///////////////////////////////////////////////////////////////////////////
  31. // File name handling
  32. //
  33. CString GetFileDirectory(const CString& path)
  34. {
  35. ASSERT(path.GetLength());
  36. int pos = path.ReverseFind('\');
  37. if (pos >= 0)
  38. return path.Left(pos);
  39. return "";
  40. }
  42. CString GetFileName(const CString& path)
  43. {
  44. ASSERT(path.GetLength());
  45. int pos = path.ReverseFind('\');
  46. if (pos >= 0)
  47. return path.Right(path.GetLength() - pos - 1);
  48. return "";
  49. }
  51. CString GetFileExt(const CString& path)
  52. {
  53. ASSERT(path.GetLength());
  54. int pos = path.ReverseFind('.');
  55. if (pos >= 0)
  56. return path.Right(path.GetLength() - pos - 1);
  57. return "";
  58. }
  60. CString GetFileTitle(const CString& path)
  61. {
  62. ASSERT(path.GetLength());
  63. CString strResult = GetFileName(path);
  64. int pos = strResult.ReverseFind('.');
  65. if (pos >= 0)
  66. return strResult.Left(pos);
  67. return strResult;
  68. }
  70. ///////////////////////////////////////////////////////////////////////////
  71. // Layer Management
  72. //
  73. void AddLayer(CMap1& map)
  74. {
  75. CString filter(TEXT("ESRI Shapefiles (*.shp)|*.shp|"));
  76. CString allFormats = TEXT("All supported formats|*.shp");
  78. #if 0
  79. // add the image filters to the end of the string
  80. ImageFactory::FormatDescArray formats;
  81. ImageFactory::QueryFormats(formats);
  83. for (int i = 0; i < formats.GetSize(); i++)
  84. {
  85. if (formats[i].m_extensions.GetLength() == 0) continue;
  87. filter += formats[i].m_name + TEXT("|");
  88. filter += formats[i].m_extensions + TEXT("|");
  90. allFormats += TEXT(";") + formats[i].m_extensions;
  91. }
  93. filter = allFormats + TEXT("|") + filter + TEXT("|");
  94. #endif
  96. CFileDialog dlg(TRUE, TEXT(".shp"), 0, OFN_FILEMUSTEXIST | OFN_HIDEREADONLY, filter);
  98. if (dlg.DoModal() == IDOK)
  99. {
  100. CString ext = GetFileExt(dlg.GetPathName());
  101. if (ext.CompareNoCase(TEXT("shp")) == 0)
  102. AddLayer(map, dlg.GetPathName());
  103. else
  104. AddImageLayer(map, dlg.GetPathName());
  106. }
  107. }
  109. void AddLayer(CMap1& map, const CString& path, COLORREF color, LPDISPATCH renderer)
  110. {
  111. // Establish connection to data
  112. CMoDataConnection conn;
  113. if (!conn.CreateDispatch(TEXT("MapObjects2.DataConnection")))
  114. throw "unable to create MapObjects2.DataConnection";
  115. conn.SetDatabase(GetFileDirectory(path));
  116. if (!conn.Connect())
  117. throw "unable to connect to database";
  119. // Add layer specified by path
  120. CMoLayers layers(map.GetLayers());
  121. CMoMapLayer layer;
  122.   if (!layer.CreateDispatch(TEXT("MapObjects2.MapLayer")))
  123. throw "unable to create MapObjects2.MapLayer";
  125. CMoGeoDataset geoDataset(conn.FindGeoDataset(GetFileTitle(path)));
  126. layer.SetGeoDataset(geoDataset);
  127. if (color != -1) // Set color if specified
  128. {
  129. CMoSymbol layerSymbol(layer.GetSymbol());
  130. layerSymbol.SetColor(color);
  131. }
  133. if (renderer)
  134. layer.SetRenderer(renderer);
  136. layers.Add(layer);
  137. }
  139. void AddLabelLayer(CMap1& map, const CString& path, LPCTSTR labelField, COLORREF color)
  140. {
  141. // Establish connection to data
  142. CMoDataConnection conn;
  143. if (!conn.CreateDispatch(TEXT("MapObjects2.DataConnection")))
  144. throw "unable to create MapObjects2.DataConnection";
  145. conn.SetDatabase(GetFileDirectory(path));
  146. if (!conn.Connect())
  147. throw "unable to connect to database";
  149. // Add layer specified by path
  150. CMoLayers layers(map.GetLayers());
  151. CMoMapLayer layer;
  152.   if (!layer.CreateDispatch(TEXT("MapObjects2.MapLayer")))
  153. throw "unable to create MapObjects2.MapLayer";
  154. CMoGeoDataset geoDataset(conn.FindGeoDataset(GetFileTitle(path)));
  155. layer.SetGeoDataset(geoDataset);
  157. // Setup label renderer
  158. CMoLabelRenderer lr;
  159. lr.CreateDispatch("MapObjects2.LabelRenderer");
  160. lr.SetField(labelField);
  161. lr.SetDrawBackground(FALSE);
  163. CMoTextSymbol sym(lr.GetSymbol(0));
  164. CFontHolder font(0);
  165. const FONTDESC fd = { sizeof(FONTDESC), OLESTR("Arial"), FONTSIZE(12), FW_NORMAL, ANSI_CHARSET, FALSE, FALSE, FALSE };
  166. //font.InitializeFont(&fd, sym.GetFont());
  167. font.InitializeFont(&fd);
  168. sym.SetFont(font.GetFontDispatch());
  169. if (color != -1)
  170. sym.SetColor(color);
  171. sym.SetVerticalAlignment(moAlignBottom);
  172. sym.SetHorizontalAlignment(moAlignLeft);
  174. layer.SetRenderer(lr);
  176. layers.Add(layer);
  177. }
  180. void AddImageLayer(CMap1& map, const CString& path)
  181. {
  182. // Establish connection to data
  183. CMoDataConnection conn;
  184. if (!conn.CreateDispatch(TEXT("MapObjects2.DataConnection")))
  185. throw "unable to create MapObjects2.DataConnection";
  187. conn.SetDatabase(GetFileDirectory(path));
  188. if (!conn.Connect())
  189. throw "unable to connect to database";
  191. // Add image layer
  192. CMoLayers layers(map.GetLayers());
  193. CMoImageLayer image;
  194.   if (!image.CreateDispatch(TEXT("MapObjects2.ImageLayer")))
  195. throw "unable to create MapObjects2.ImageLayer";
  196. image.SetFile(path);
  197. layers.Add(image);
  198. }
  201. void AddSDELayer(CMap1& map, LPCTSTR server, LPCTSTR user, 
  202.  LPCTSTR password, LPCTSTR db, COLORREF color)
  203. {
  204. // Establish connection to data
  205. CMoDataConnection conn;
  206. if (!conn.CreateDispatch(TEXT("MapObjects2.DataConnection")))
  207. throw "unable to create MapObjects2.DataConnection";
  208. conn.SetServer(server);
  209. conn.SetUser(user);
  210. conn.SetPassword(password);
  211. conn.SetDatabase(db);
  212. if (!conn.Connect())
  213. throw "unable to connect to database";
  215. // Add layer specified by path
  216. CMoLayers layers(map.GetLayers());
  217. CMoMapLayer layer;
  218.   if (!layer.CreateDispatch(TEXT("MapObjects2.MapLayer")))
  219. throw "unable to create MapObjects2.MapLayer";
  220. CMoGeoDataset geoDataset(conn.FindGeoDataset(db));
  221. layer.SetGeoDataset(geoDataset);
  222. if (color != -1) // Set color if specified
  223. {
  224. CMoSymbol layerSymbol(layer.GetSymbol());
  225. layerSymbol.SetColor(color);
  226. }
  227. layers.Add(layer);
  228. }
  230. //
  231. // All layer objects support the GetLayerType method.
  232. // Each object's dispatch ID for the property is different 
  233. // though.  Given the object's dispatch pointer, lookup 
  234. // the dispatch ID for the LayerType property then call 
  235. // Invoke to get the layer type.
  236. //
  237. short GetLayerType(CMoLayers& layers, short layerNum)
  238. {
  239. USES_CONVERSION;
  240. short layerType = -1;
  241. LPCOLESTR lpOleStr = T2COLE(TEXT("LayerType"));
  242. DISPID dispID = -1;
  244. COleDispatchDriver dd(layers.Item(COleVariant(layerNum)));
  245. if (SUCCEEDED(LPDISPATCH(dd)->GetIDsOfNames(IID_NULL,
  246. (LPOLESTR*)&lpOleStr, 1, 0, &dispID)))
  247. {
  248. dd.GetProperty(dispID, VT_I2, &layerType);
  249. }
  251. return layerType;
  252. }
  256. //
  257. // Works with Redlands sample data
  258. //
  259. LPDISPATCH CreateStreetRenderer()
  260. {
  261. CMoSymbol sym;
  262. CMoValueMapRenderer vr;
  263. VERIFY(vr.CreateDispatch("MapObjects2.ValueMapRenderer"));
  265. vr.SetField(TEXT("CFCC"));
  266. vr.SetSymbolType(moLineSymbol);
  267. vr.SetValueCount(6);
  269. vr.SetValue(0, TEXT("A11"));
  270. sym.AttachDispatch(vr.GetSymbol(0));
  271. sym.SetColor(moBlue);
  272. sym.SetSize(9);
  274. vr.SetValue(1, TEXT("A15"));
  275. sym.AttachDispatch(vr.GetSymbol(1));
  276. sym.SetColor(moBlue);
  277. sym.SetSize(9);
  279. vr.SetValue(2, TEXT("A20"));
  280. sym.AttachDispatch(vr.GetSymbol(2));
  281. sym.SetColor(moNavy);
  282. sym.SetSize(5);
  284. vr.SetValue(3, TEXT("A21"));
  285. sym.AttachDispatch(vr.GetSymbol(3));
  286. sym.SetColor(moNavy);
  287. sym.SetSize(5);
  289. vr.SetValue(4, TEXT("A31"));
  290. sym.AttachDispatch(vr.GetSymbol(4));
  291. sym.SetColor(moBrown);
  292. sym.SetSize(2);
  294. vr.SetValue(5, TEXT("A63"));
  295. sym.AttachDispatch(vr.GetSymbol(5));
  296. sym.SetColor(moRed);
  297. sym.SetSize(5);
  299. sym.AttachDispatch(vr.GetDefaultSymbol());
  300. sym.SetColor(moGray);
  301. sym.SetSize(2);
  303. LPDISPATCH(vr)->AddRef();
  304. return LPDISPATCH(vr);
  305. }
  307. ///////////////////////////////////////////////////////////////////////////
  308. // Zoom and Pan
  309. //
  310. void ZoomIn(CMap1& map) 
  311. {
  312. CMoRectangle r(map.TrackRectangle());
  313. if (LPDISPATCH(r))
  314. map.SetExtent(r);
  315. }
  317. void ZoomOut(CMap1& map) 
  318. {
  319. CMoRectangle r(map.GetExtent());
  320. ASSERT(LPDISPATCH(r));
  321. r.ScaleRectangle(1.5);
  322. map.SetExtent(r);
  323. }
  325. void ZoomFull(CMap1& map) 
  326. {
  327. CMoRectangle r(map.GetFullExtent());
  328. ASSERT(LPDISPATCH(r));
  329. map.SetExtent(r);
  330. }
  332. void Pan(CMap1& map) 
  333. {
  334. map.Pan();
  335. }
  337. void Resize(CMap1& map, int cx, int cy, int border) 
  338. {
  339. if (map.m_hWnd)
  340. map.SetWindowPos(0, border, border, cx - border, cy - border, SWP_NOZORDER);
  341. }
  343. ///////////////////////////////////////////////////////////////////////////
  344. // Conversion
  345. //
  346. double DegreesToMiles(double x1, double y1, double x2, double y2)
  347. {
  348. // H. Andoyer: [Annuaire du Bureau des Longitudes, 1950, Paris, p. 145] 
  349. if (x1 == x2 && y1 == y2)
  350. return 0;
  352. double a = 6378137;      // Use GRS 80 spheroid 
  353. double f = 0.003352813;  // 1 / 298.257 
  355. double F = (DEG2RAD(y1) + DEG2RAD(y2)) / 2.0;
  356. double G = (DEG2RAD(y1) - DEG2RAD(y2)) / 2.0;
  357. double l = (DEG2RAD(x1) - DEG2RAD(x2)) / 2.0;
  359. double sF2 = pow(sin(F),2);
  360. double cF2 = pow(cos(F),2);
  361. double sG2 = pow(sin(G),2);
  362. double cG2 = pow(cos(G),2);
  363. double sL2 = pow(sin(l),2);
  364. double cL2 = pow(cos(l),2);
  366. double S = sG2*cL2 + cF2*sL2;
  367. double C = cG2*cL2 + sF2*sL2;
  369. double omega = atan(sqrt(S/C));
  370. double rho = sqrt(S*C) / omega;
  372. double D = 2*a*omega;
  374. double H1 = (3*rho - 1) / (2*C);
  375. double H2 = (3*rho + 1) / (2*S);
  377. double m = D*(1 + f*(H1*sF2*cG2 - H2*cF2*sG2));
  379. return m * 0.0006214;
  380. }
  384. ///////////////////////////////////////////////////////////////////////////
  385. // Miscellaneous
  386. //
  387. LPDISPATCH GetIDispatch(CMap1& map)
  388. {
  389. LPDISPATCH pDispatch = 0;
  390. LPUNKNOWN pUnknown = map.GetControlUnknown();
  391. if (pUnknown)
  392. pUnknown->QueryInterface(IID_IDispatch, (void**)&pDispatch);
  393. return pDispatch;
  394. }
  397. double GetAspectRatio(CMap1& map)
  398. {
  399. CMoRectangle r(map.GetExtent());
  400. return (double)r.GetWidth() / (double)r.GetHeight();
  401. }
  404. //
  405. // Use ratio of map to window to calculate map point
  406. //
  407. LPDISPATCH ToMapPoint(CMap1& map, long x, long y)
  408. {
  409. ASSERT(map.m_hWnd);
  410. CRect client;
  411. map.GetClientRect(&client);
  412. CMoRectangle bounds(map.GetExtent());
  414. double mapX = bounds.GetLeft() + (double)x * bounds.GetWidth() / (double)client.Width();
  415. double mapY = bounds.GetTop() - (double)y * bounds.GetHeight() / (double)client.Height();
  417. CMoPoint mapPoint;
  418. mapPoint.CreateDispatch(TEXT("MapObjects2.Point"));
  419. mapPoint.SetX(mapX);
  420. mapPoint.SetY(mapY);
  421. LPDISPATCH(mapPoint)->AddRef(); // Client is responsible for release
  422. return mapPoint;
  423. }
  425. void FromMapPoint(CMap1& map, CMoPoint& pt, long& x, long& y)
  426. {
  427. ASSERT(map.m_hWnd);
  428. CRect client;
  429. map.GetClientRect(&client);
  431. CMoRectangle bounds(map.GetExtent());
  433. x = (long)MULDIV((pt.GetX() - bounds.GetLeft()), client.Width(), bounds.GetWidth());
  434. y = (long)MULDIV((bounds.GetTop() - pt.GetY()),  client.Height(), bounds.GetHeight());
  435. }
  437. double ToMapDistance(CMap1& map, long x)
  438. { 
  439. ASSERT(map.m_hWnd); 
  440. CRect client; 
  441. map.GetClientRect(&client);
  443. CMoRectangle bounds(map.GetExtent());
  444. return (double)x * bounds.GetWidth() / (double)client.Width(); 
  445. }
  447. long FromMapDistance(CMap1& map, double& mapX)
  448. {
  449. ASSERT(map.m_hWnd);
  450. CRect client;
  451. map.GetClientRect(&client);
  453. CMoRectangle bounds(map.GetExtent());
  455. return (long)MULDIV(mapX, client.Width(), bounds.GetWidth());
  456. }
  458. ///////////////////////////////////////////////////////////////////////////
  459. // Geodatasets
  460. //
  461. void SetValue(CMoFields& fields, LPCTSTR name, VARIANT& value)
  462. {
  463. // Find the field
  464. CMoField field(fields.Item(COleVariant(name)));
  466. // Set the field value
  467. field.SetValue(value);
  468. }
  470. void SetValue(CMoFields& fields, LPCTSTR name, const LONG value)
  471. {
  472. VARIANT v;
  473. v.vt = VT_I4;
  474. v.lVal = value;
  475. SetValue(fields, name, v);
  476. }
  478. void SetValue(CMoFields& fields, LPCTSTR name, const double value)
  479. {
  480. VARIANT v;
  481. v.vt = VT_R8;
  482. v.dblVal = value;
  483. SetValue(fields, name, v);
  484. }
  486. void SetValue(CMoFields& fields, LPCTSTR name, const COleDateTime& value)
  487. {
  488. VARIANT v;
  489. v.vt = VT_DATE;
  490. v.date = value.m_dt;
  491. SetValue(fields, name, v);
  492. }
  494. void SetValue(CMoFields& fields, LPCTSTR name, const LPCTSTR value)
  495. {
  496. SetValue(fields, name, COleVariant(value));
  497. }
  499. void SetValue(CMoFields& fields, LPCTSTR name, const BOOL value)
  500. {
  501. VARIANT v;
  502. v.vt = VT_BOOL;
  503. v.bVal = value;
  504. SetValue(fields, name, v);
  505. }
  507. void SetValue(CMoFields& fields, LPCTSTR name, const LPDISPATCH value)
  508. {
  509. VARIANT v;
  510. v.vt = VT_DISPATCH;
  511. v.pdispVal = value;
  512. SetValue(fields, name, v);
  513. }
  516. ///////////////////////////////////////////////////////////////////////////
  517. // Printing and Export
  518. //
  519. static void S_AdjustWidthToRatio(CRect& r, const double ratio, const UINT align = DT_CENTER)
  520. {
  521. int newWidth = (int)MULT(r.Height(), ratio);
  522. int offset;
  523. if (align & DT_CENTER)
  524. offset = (int)DIV((double)r.Width() - newWidth, 2);
  525. else if (align & DT_RIGHT)
  526. offset = r.Width() - newWidth;
  527. else
  528. offset = 0;
  529. r.left += offset;
  530. r.right = r.left + newWidth;
  531. }
  533. static void S_AdjustHeightToRatio(CRect& r, const double ratio, const UINT align = DT_VCENTER)
  534. {
  535. int newHeight = (int)DIV(r.Width(), ratio);
  536. int offset;
  537. if (align & DT_VCENTER)
  538. offset = (int)DIV((double)r.Height() - newHeight, 2);
  539. else if (align & DT_BOTTOM)
  540. offset = r.Height() - newHeight;
  541. else 
  542. offset = 0;
  543. r.top += offset;
  544. r.bottom = r.top + newHeight;
  545. }
  547. //
  548. // Adjust the rectangle to match the aspect ratio specified
  549. // Use the following values or'd together for alignment:
  550. //
  551. // DT_TOP,  DT_VCENTER, DT_BOTTOM
  552. // DT_LEFT, DT_CENTER,  DT_RIGHT
  553. //
  554. CRect AdjustToRatio(const CRect& r, const double ratio, const UINT align)
  555. {
  556. CRect newRect = r;
  558. // First try simple adjustment
  559. if (ratio < 1.0)
  560. S_AdjustWidthToRatio(newRect, ratio, align);
  561. else
  562. S_AdjustHeightToRatio(newRect, ratio, align);
  564. // Didn't fit.  Adjust again.
  565. if (r.Width() < newRect.Width())
  566. {
  567. newRect.left = r.left;
  568. newRect.right = r.right;
  569. S_AdjustHeightToRatio(newRect, ratio, align);
  570. }
  571. if (r.Height() < newRect.Height())
  572. {
  573. newRect.top = r.top;
  574. newRect.bottom = r.bottom;
  575. S_AdjustWidthToRatio(newRect, ratio, align);
  576. }
  578. return newRect;
  579. }
  582. //
  583. // Calculate the size of the output device in pixels
  584. //
  585. CRect GetDeviceRect(CDC* pDC)
  586. {
  587. CRect devRect;
  588. // HDC hDC = pDC->m_hAttribDC;
  589. HDC hDC = pDC->GetSafeHdc();
  591. int type = ::GetObjectType(hDC);
  592. switch (type)
  593. {
  594. case OBJ_DC: // Printer or screen
  595. //
  596. // If there's a window associated with 
  597. // the DC, use the client area.  Otherwise
  598. // use the device width.
  599. //
  600. HWND hWnd;
  601. if (hWnd = ::WindowFromDC(hDC))
  602. ::GetClientRect(hWnd, &devRect);
  603. else
  604. devRect.SetRect(0, 0, pDC->GetDeviceCaps(HORZRES), pDC->GetDeviceCaps(VERTRES));
  605. break;
  607. case OBJ_MEMDC: // Memory bitmap
  608. //
  609. // Use the bitmap size
  610. //
  611. HBITMAP hBitmap;
  612. hBitmap = (HBITMAP)::GetCurrentObject(pDC->GetSafeHdc(), OBJ_BITMAP);
  613. if (!hBitmap)
  614. throw "error with memory DC";
  615. BITMAP bm;
  616. VERIFY(::GetObject(hBitmap, sizeof(BITMAP), &bm));
  617. if (bm.bmWidth == 0 || bm.bmHeight == 0)
  618. throw "error with memory DC";;
  620. devRect.SetRect(0, 0, bm.bmWidth, bm.bmHeight);
  621. break;
  623. default: 
  624. devRect.SetRect(0, 0, pDC->GetDeviceCaps(HORZRES), pDC->GetDeviceCaps(VERTRES));
  625. if (devRect.right == 0)
  626. {
  627. CClientDC dc(0);
  628. devRect.SetRect(0, 0, dc.GetDeviceCaps(HORZRES), dc.GetDeviceCaps(VERTRES));
  629. }
  630. break;
  631. }
  633. return devRect;
  634. }
  636. //
  637. // Work-around that allows you to draw maps on an old style windows
  638. // metafile.
  639. //
  640. void OutputMap(CMap1& map, CMetaFileDC* pDC)
  641. {
  642. map.ExportMap(moExportClipboardEMF, TEXT("TRUE"), 1.0); // system generates old-style metafile
  644. if (::OpenClipboard(::GetFocus()))
  645. {
  646. HANDLE hMFP = ::GetClipboardData(CF_METAFILEPICT);
  647. METAFILEPICT* pMFP = (METAFILEPICT*)::GlobalLock(hMFP);
  648. if (pMFP)
  649. {
  650. VERIFY(::PlayMetaFile(pDC->GetSafeHdc(), pMFP->hMF));
  651. ::GlobalUnlock(hMFP);
  652. }
  654. VERIFY(::CloseClipboard());
  655. }
  656. }
  658. //
  659. // Draw the map, scaling it to a frame on the surface of the 
  660. // device referenced by the DC.  If the frame doesn't match the
  661. // aspect ratio of the map, the map is position as specified 
  662. // by hAlign and vAlign within the frame.  Use the following
  663. // values or'd together for alignment:
  664. //
  665. // DT_TOP,  DT_VCENTER, DT_BOTTOM
  666. // DT_LEFT, DT_CENTER,  DT_RIGHT
  667. //
  668. void FrameMap(CMap1& map, CDC* pDC, const CRect& dstRect, const UINT align)
  669. {
  670. //
  671. // Create a frame of the same aspect ratio as the map and 
  672. // center or left justify it in dstRect.
  673. //
  674. double aspectRatio = GetAspectRatio(map);
  675. CRect frame = AdjustToRatio(dstRect, aspectRatio, align);
  677. //
  678. // Use GDI to position map on page
  679. //
  680. CRect devRect = AdjustToRatio(GetDeviceRect(pDC), aspectRatio);
  681. int saveID = pDC->SaveDC();
  683. pDC->SetMapMode(MM_ISOTROPIC); 
  684. pDC->SetWindowOrg(devRect.left, devRect.top); 
  685. pDC->SetWindowExt(devRect.Width(), devRect.Height()); 
  686. pDC->SetViewportOrg(frame.left, frame.top);
  687. pDC->SetViewportExt(frame.Width(), frame.Height());
  689. map.OutputMap((OLE_HANDLE)pDC->GetSafeHdc());
  691. pDC->RestoreDC(saveID);
  693. #if 0
  694. // Rectangles for testing
  695. HBRUSH hBrush = (HBRUSH)::GetStockObject(NULL_BRUSH);
  696. HBRUSH hOldBrush = (HBRUSH)::SelectObject(pDC->GetSafeHdc(), hBrush);
  697. pDC->Rectangle(dstRect);
  699. HPEN   hPen = (HPEN)::CreatePen(PS_SOLID, 0, RGB(255, 0, 0));
  700. HPEN   hOldPen = (HPEN)::SelectObject(pDC->GetSafeHdc(), hPen);
  701. pDC->Rectangle(frame);
  702. ::SelectObject(pDC->GetSafeHdc(), hOldPen);
  704. ::SelectObject(pDC->GetSafeHdc(), hOldBrush);
  705. #endif
  706. }
  709. ///////////////////////////////////////////////////////////////////////////
  710. // OLE Fonts
  711. //
  712. CMoFont::CMoFont()
  713. : CFontHolder(0),
  714. m_pFontDisp(0),
  715. m_pDispatch(0)
  716. {
  717. CFontDesc fontDesc;
  718. InitializeFont(&fontDesc, 0);
  719. }
  722. CMoFont::CMoFont(LPFONTDISP pFontDisp)
  723. : CFontHolder(0)
  724. {
  725. InitializeFont(0, pFontDisp);
  726. // similar to COleDispatchDriver::CreateDispatch()
  727. }
  729. CMoFont::~CMoFont()
  730. {
  731. ReleaseDispatch();
  732. }
  734. void CMoFont::AttachDispatch(LPFONTDISP pFontDisp)
  735. {
  736. ReleaseDispatch();
  737. InitializeFont(0, pFontDisp);
  738. }
  740. void CMoFont::ReleaseDispatch()
  741. {
  742. if (m_pFontDisp)
  743. {
  744. m_pFontDisp->Release();
  745. m_pFontDisp = 0;
  746. }
  748. if (m_pDispatch)
  749. {
  750. m_pDispatch->Release();
  751. m_pDispatch = 0;
  752. }
  753. }
  755. CMoFont::operator LPFONTDISP() 
  756. { 
  757. if (m_pFontDisp == 0)
  758. m_pFontDisp = GetFontDispatch(); // must release;
  760. return m_pFontDisp; 
  761. }
  763. CMoFont::operator LPDISPATCH() 
  764. { 
  765. if (m_pDispatch == 0)
  766. {
  767. LPFONTDISP pFontDisp = this->operator LPFONTDISP();
  768. pFontDisp->QueryInterface(IID_IDispatch, (void**)&m_pDispatch); // must release;
  769. }
  771. return m_pDispatch; 
  772. }
  774. LPCTSTR CMoFont::GetName()
  775. {
  776. USES_CONVERSION;
  777. ASSERT(m_pFont);
  778. BSTR pName;   
  779. m_pFont->get_Name(&pName);
  780. return OLE2T(pName);
  781. }
  783. void CMoFont::SetName(LPCTSTR name)
  784. {
  785. USES_CONVERSION;
  786. ASSERT(m_pFont);
  787. m_pFont->put_Name(T2OLE(name));
  788. }
  790. long CMoFont::GetSize()
  791. {
  792. ASSERT(m_pFont);
  793. CY size;
  794. m_pFont->get_Size(&size);
  795. return (long)DIV(size.int64, 10000);
  796. }
  798. void CMoFont::SetSize(long size)
  799. {
  800. ASSERT(m_pFont);
  801. CY _size = { size * 10000, 0 };
  802. m_pFont->put_Size(_size);
  803. }
  805. short CMoFont::GetWeight()
  806. {
  807. ASSERT(m_pFont);
  808. short weight;
  809. m_pFont->get_Weight(&weight);
  810. return weight;
  811. }
  813. void CMoFont::SetWeight(short weight)
  814. {
  815. ASSERT(m_pFont);
  816. m_pFont->put_Weight(weight);
  817. }
  819. short CMoFont::GetCharSet()
  820. {
  821. ASSERT(m_pFont);
  822. short charSet;
  823. m_pFont->get_Charset(&charSet);
  824. return charSet;
  825. }
  827. void CMoFont::SetCharSet(short charset)
  828. {
  829. ASSERT(m_pFont);
  830. m_pFont->put_Charset(charset);
  831. }
  833. BOOL CMoFont::GetItalic()
  834. {
  835. ASSERT(m_pFont);
  836. BOOL flag;
  837. m_pFont->get_Italic(&flag);
  838. return flag;
  839. }
  841. void CMoFont::SetItalic(BOOL italic)
  842. {
  843. ASSERT(m_pFont);
  844. m_pFont->put_Italic(italic);
  845. }
  847. BOOL CMoFont::GetUnderline()
  848. {
  849. ASSERT(m_pFont);
  850. BOOL flag;
  851. m_pFont->get_Underline(&flag);
  852. return flag;
  853. }
  855. void CMoFont::SetUnderline(BOOL underline)
  856. {
  857. ASSERT(m_pFont);
  858. m_pFont->put_Underline(underline);
  859. }
  861. BOOL CMoFont::GetStrikeThrough()
  862. {
  863. ASSERT(m_pFont);
  864. BOOL flag;
  865. m_pFont->get_Strikethrough(&flag);
  866. return flag;
  867. }
  869. void CMoFont::SetStrikeThrough(BOOL strikeThrough)
  870. {
  871. ASSERT(m_pFont);
  872. m_pFont->put_Strikethrough(strikeThrough);
  873. }
  877. ///////////////////////////////////////////////////////////////////////////
  878. // Collection Iterator
  879. //
  880. CMoIterator::CMoIterator(COleDispatchDriver& collection)
  881. : m_pEnumVariant(0)
  882. {
  883. //
  884. // Find out if collection is really a collection
  885. // by querying for the _NewEnum property and 
  886. // assigning the m_pEnumVariant pointer to it.
  887. //
  888. USES_CONVERSION;
  889. LPCOLESTR pName = T2COLE(TEXT("_NewEnum"));
  890. DISPID dispID = -1;
  891. if (!SUCCEEDED(LPDISPATCH(collection)->GetIDsOfNames(IID_NULL, (OLECHAR**)&pName, 1, 0, &dispID)))
  892. throw "invalid collection object";
  894. LPUNKNOWN pUnknown = 0;
  895. collection.GetProperty(dispID, VT_UNKNOWN, &pUnknown);
  896. if (pUnknown == 0)
  897. throw "unable to get IUnknown for collection object";
  899. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&m_pEnumVariant);
  900. pUnknown->Release();
  901. if (m_pEnumVariant == 0) 
  902. throw "unable to get IEnumVARIANT for collection object";
  904. Reset(); // might not need this.
  905. // success, collection has _NewEnum property!
  907. }
  909. //
  910. // Sets item to next element of collection
  911. // 
  912. BOOL CMoIterator::Next(COleDispatchDriver& item)
  913. {
  914. HRESULT result = S_FALSE;
  915. ASSERT(m_pEnumVariant);
  916. if (m_pEnumVariant)
  917. {
  918. ULONG c;
  919. VARIANT v;
  920. result = m_pEnumVariant->Next(1, &v, &c);
  921. if (result == S_OK && c == 1)
  922. {
  923. v.pdispVal->AddRef(); // Next should do this but doesn't
  924. item.AttachDispatch(v.pdispVal);
  925. }
  926. }
  928. return (result == S_OK);
  929. }
  931. void CMoIterator::Reset()
  932. {
  933. ASSERT(m_pEnumVariant);
  934. if (m_pEnumVariant)
  935. m_pEnumVariant->Reset();
  936. }
  938. void CMoIterator::Skip(unsigned long index)
  939. {
  940. ASSERT(m_pEnumVariant);
  941. if (m_pEnumVariant)
  942. m_pEnumVariant->Skip(index);
  943. }
  945. CMoIterator::~CMoIterator() 
  946. {
  947. if (m_pEnumVariant)
  948. m_pEnumVariant->Release();
  949. }
  953. IUnknown* CreateCOMObject(const GUID& clsid, IUnknown* pOuter)
  954. {
  955. USES_CONVERSION;
  956. IUnknown* pUnknown = 0;
  958. IClassFactory* pFactory = 0;
  959. HRESULT hr = CoGetClassObject(clsid, CLSCTX_ALL, 0, IID_IClassFactory, (void**)&pFactory);
  960. if (SUCCEEDED(hr))
  961. {
  962. hr = pFactory->CreateInstance(pOuter, IID_IUnknown, (void**)&pUnknown);
  963. pFactory->Release();
  964. }
  966. return pUnknown;
  967. }