pagemaplayerprop.cpp

一个英国人写的GIS查看/编辑工具。支持标准的shapefile地图文件格式和coverage地图文件格式。同时可以编辑相应的dbf文件。

/////////////////////////////////////////////////////////////////////////////

void CPageMapLayerProp::OnOK() 
{
   m_pMapLayer->GetMapProp() = *m_pMapProperty;
	
	CPropertyPage::OnOK();
}

/////////////////////////////////////////////////////////////////////////////

CMapStyle CPageMapLayerProp::GetStyle(int nValue, int index)
{
   // Retrieve the colour according to the currently selected colour scheme

   if (index == -1) index = m_cbColourScheme.GetCurSel();
   if (index == -1 || m_aStyleSchemes[index].m_aStyle.GetSize() == 0) return CMapStyle();

   return m_aStyleSchemes[index].m_aStyle[nValue % m_aStyleSchemes[index].m_aStyle.GetSize()];

   
}

///////////////////////////////////////////////////////////////////////////////
//
// Change the colours to the new colour scheme
//
 
void CPageMapLayerProp::OnSelchangeColourscheme() 
{
   SepColour(FALSE);
   RangeColour(FALSE);
}

///////////////////////////////////////////////////////////////////////////////
//
// Initialise the colour scheme
//

void CPageMapLayerProp::InitScheme(CStyleScheme& scheme, COLORREF crMin, COLORREF crMax)
{
   scheme.m_aStyle.RemoveAll();

   for (int lum = 220; lum >= 0; lum -= 60)
   {
      for (int sat = 240; sat >= 0; sat -= 40)      
      {
         for (int hue = 0; hue <= 240; hue += 15)         
         {
             COLORREF cr = HLStoRGB(hue, lum, sat);

            WORD r = GetRValue(cr);
            WORD g = GetGValue(cr);
            WORD b = GetBValue(cr);
             
            if (GetRValue(crMin) <= r && r <= GetRValue(crMax) && 
                GetGValue(crMin) <= g && g <= GetGValue(crMax) && 
                GetBValue(crMin) <= b && b <= GetBValue(crMax))
            {
                CMapStyle mapstyle;
                if (m_pMapProperty->m_bPolygon)
                {
                   mapstyle.m_crFill = RGB(r,g,b);
                } else
                {
                   mapstyle.m_crLine = RGB(r,g,b);
                }
                scheme.m_aStyle.Add(mapstyle);     
            }
  
         }
      }
   }
   
}


///////////////////////////////////////////////////////////////////////////////
//
// Source: Microsoft knowledge base
//

WORD HueToRGB(WORD n1, WORD n2, WORD hue)  
{ 

   /* range check: note values passed add/subtract thirds of range */
   if (hue < 0)
      hue += HLSMAX;

   if (hue > HLSMAX)
      hue -= HLSMAX;

   /* return r,g, or b value from this tridrant */
   if (hue < (HLSMAX/6))
      return ( n1 + (((n2-n1)*hue+(HLSMAX/12))/(HLSMAX/6)) );
   if (hue < (HLSMAX/2))
      return ( n2 );
   if (hue < ((HLSMAX*2)/3))
      return ( n1 + (((n2-n1)*(((HLSMAX*2)/3)-hue)+(HLSMAX/12))/(HLSMAX/6))

); 
   else
      return ( n1 );

} 

///////////////////////////////////////////////////////////////////////////////

DWORD HLStoRGB(WORD hue, WORD lum, WORD sat)
{ 

   WORD R,G,B;                /* RGB component values */
   WORD  Magic1,Magic2;       /* calculated magic numbers (really!) */

   if (sat == 0) {            /* achromatic case */
      R=G=B=(lum*RGBMAX)/HLSMAX;
      if (hue != UNDEFINED) {
         /* ERROR */
      }
   }
   else  {                    /* chromatic case */
      /* set up magic numbers */
      if (lum <= (HLSMAX/2))
         Magic2 = (lum*(HLSMAX + sat) + (HLSMAX/2))/HLSMAX;
      else
         Magic2 = lum + sat - ((lum*sat) + (HLSMAX/2))/HLSMAX;
      Magic1 = 2*lum-Magic2;

      /* get RGB, change units from HLSMAX to RGBMAX */
      R = (HueToRGB(Magic1,Magic2,hue+(HLSMAX/3))*RGBMAX +

(HLSMAX/2))/HLSMAX; 
      G = (HueToRGB(Magic1,Magic2,hue)*RGBMAX + (HLSMAX/2)) / HLSMAX;
      B = (HueToRGB(Magic1,Magic2,hue-(HLSMAX/3))*RGBMAX +

(HLSMAX/2))/HLSMAX; 
   }

   return(RGB(R,G,B));

} 

///////////////////////////////////////////////////////////////////////////////

void CPageMapLayerProp::InitSchemes()
{
   CStyleScheme scheme;
   CMapStyle mapstyle;
   CString s, sStyle;

// Save existing values before re-initialising schemes

   OnKillActive();

// Remove existing schemes from list

   m_aStyleSchemes.RemoveAll();

// Load the custom schemes first

   CXMLFile xmlfile;
   if (!xmlfile.Read(BDGetAppPath() + SCHEMEFILE) && 
       access(BDGetAppPath() + SCHEMEFILE, 00) == 0)
   {
      AfxMessageBox("Error reading: " + BDGetAppPath() + SCHEMEFILE);
   }

// Convert xml object to scheme

   m_aStyleSchemes.XMLAs(&xmlfile);   

// Create default schemes

   scheme.m_bSystem = TRUE;
   scheme.m_sName = BDString(IDS_NATURAL);
   InitScheme(scheme, RGB(152,152,0), RGB(255,255,128));
   m_aStyleSchemes.Add(scheme);
   scheme.m_sName = BDString(IDS_BLUES);
   InitScheme(scheme, RGB(0,0,128), RGB(96,128,255));
   m_aStyleSchemes.Add(scheme);
   scheme.m_sName = BDString(IDS_GREENS);
   InitScheme(scheme, RGB(0,128,0), RGB(96,255,152));
   m_aStyleSchemes.Add(scheme);
   scheme.m_sName = BDString(IDS_REDS);
   InitScheme(scheme, RGB(196,0,0), RGB(255,96,96));
   m_aStyleSchemes.Add(scheme);
   scheme.m_sName = BDString(IDS_AQUATIC);
   InitScheme(scheme, RGB(0,96,96), RGB(48,255,255));
   m_aStyleSchemes.Add(scheme);
   scheme.m_sName = BDString(IDS_PASTELS);;
   InitScheme(scheme, RGB(152,152,152), RGB(255,255,255));
   m_aStyleSchemes.Add(scheme);

   
// Add colour schemes

   m_cbColourScheme.ResetContent();
   for (int i = 0; i < m_aStyleSchemes.GetSize(); i++)
   {      
      m_cbColourScheme.AddString(m_aStyleSchemes[i].m_sName);
   };

   // Remember previous colour scheme

   DWORD dwStyle = m_cbAutoStyle.GetItemData(m_cbAutoStyle.GetCurSel());
   if (dwStyle == sepcolor)
   {
      for (int i = 0; i < m_aStyleSchemes.GetSize(); i++)
      {
         CColourFeatureArray& aColourFeature = m_pMapProperty->m_aColourFeature;
         for (int j = 0; j < aColourFeature.GetSize(); j++)
         {
            if (!(aColourFeature[j] == GetStyle(j, i))) break;
         }
         if (j == aColourFeature.GetSize())
         {
            m_cbColourScheme.SetCurSel(i);
            break;
         }
      };         
   }      

   //  Range colour scheme

   else if (dwStyle == rangecolor)
   {
      CRangeColourArray& aRangeColour = m_pMapProperty->m_aRangeColour;
      ASSERT(aRangeColour.GetSize() == m_lbLayers.GetCount());

      for (int i = 0; i < m_aStyleSchemes.GetSize(); i++)
      {
         for (int j = 0; j < aRangeColour.GetSize(); j++)
         {
            if (!(aRangeColour[j] == GetStyle(j, i))) break;            
         }
         if (j == aRangeColour.GetSize())
         {
            m_cbColourScheme.SetCurSel(i);
         }
      };
   }
}

///////////////////////////////////////////////////////////////////////////////
//
// Display menu for loading or saving scheme
//

void CPageMapLayerProp::OnSchememenu() 
{
   int index = m_cbAutoStyle.GetCurSel();
   DWORD dw = m_cbAutoStyle.GetItemData(index);   

   // Get menu
   
   CMenu menu;   

   if (dw == rangecolor)
   {
      menu.LoadMenu(IDR_ADVANCED);
   } else
   {
      menu.LoadMenu(IDR_SCHEME);   
   };

   CMenu* pMenu = menu.GetSubMenu(0);

   // Display

   CRect rect;
   m_pbSchemeMenu.GetWindowRect(&rect);

   pMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, 
                         rect.right, rect.top, this);
	
}

///////////////////////////////////////////////////////////////////////////////

void CPageMapLayerProp::OnSchemeSave() 
{
    

   // Add the new scheme to the list of schemes

   CStyleScheme scheme;

   CDlgSaveScheme dlg;
   if (dlg.DoModal() == IDOK)
   {      
      scheme.m_sName = dlg.GetName();

      for (int i = 0; i < m_lbLayers.GetCount(); i++)
      {
         CMapStyle mapstyle = m_lbLayers.GetStyle(i);
         scheme.m_aStyle.Add(mapstyle);
      };
   };

   // If there is already a scheme of the same name then replace it

   for (int i = 0; i < m_aStyleSchemes.GetSize(); i++)
   {
      if (m_aStyleSchemes[i].m_sName == scheme.m_sName)
      {
         m_aStyleSchemes.RemoveAt(i);
         break;
      }
   }

   // Add to list

   m_aStyleSchemes.InsertAt(0, scheme);

   SaveSchemes();


   // Initialise the list

   InitSchemes();
}

///////////////////////////////////////////////////////////////////////////////

void CPageMapLayerProp::SaveSchemes()
{
   // Now save the new list of schemes

   CXMLFile xmlfile;

   xmlfile.m_sName = "styleschemes";

   CXMLObj *pXMLScheme = NULL;
   
   for (int i = 0; i < m_aStyleSchemes.GetSize(); i++)
   {
      CStyleScheme rStyleScheme = m_aStyleSchemes[i];

      if (!rStyleScheme.m_bSystem)
      {
         // Add the scheme as a new child xml object

         if (i == 0) pXMLScheme = xmlfile.m_pChild = new CXMLObj;
         else pXMLScheme = pXMLScheme->m_pNext = new CXMLObj;
           
         // Add the name as an attribute

         CXMLAttr attr;
         attr.m_sName = "name";
         attr.m_sValue = rStyleScheme.m_sName;
         pXMLScheme->m_aAttr.Add(attr);
         pXMLScheme->m_sName = "stylescheme";

         // Write the styles      

         CXMLObj *pXMLStyle = NULL;

         for (int j = 0; j < rStyleScheme.m_aStyle.GetSize(); j++)
         {                  
            if (j == 0) pXMLScheme->m_pChild = pXMLStyle = new CXMLObj;
            else pXMLStyle = pXMLStyle->m_pNext = new CXMLObj;         

            pXMLStyle->m_sName = "style";

            attr.m_sName = "id";
            attr.m_sValue.Format("%i", j);
            pXMLStyle->m_aAttr.Add(attr);

            rStyleScheme.m_aStyle[j].AsXML(pXMLStyle);                  
         };
      }
   };

   xmlfile.Write(BDGetAppPath() + SCHEMEFILE);
}

///////////////////////////////////////////////////////////////////////////////

void CPageMapLayerProp::OnSchemeDelete() 
{
   CString sScheme, s;
   CStyleScheme scheme;


   // Retrieve name of scheme   

   m_cbColourScheme.GetWindowText(sScheme);
   
   for (int i = 0; i < m_aStyleSchemes.GetSize(); i++)
   {
      if (m_aStyleSchemes[i].m_sName == sScheme)
      {
         if (!m_aStyleSchemes[i].m_bSystem)
         {
            m_aStyleSchemes.RemoveAt(i);
            SaveSchemes();
            InitSchemes();
            break;
         }
      }
   }            
}

///////////////////////////////////////////////////////////////////////////////

void CPageMapLayerProp::OnAdvanced() 
{
	CDlgColourRange dlg(m_pMapLayer, m_pMapProperty);

   if (dlg.DoModal() == IDOK)
   {
      RangeColour(TRUE);      
   }	
}