Classe CDC

Define uma classe de objetos de contexto de dispositivo.

Sintaxe

class CDC : public CObject

Membros

Construtores públicos

Nome Descrição
CDC::CDC Constrói um objeto CDC.

Métodos públicos

Nome Descrição
CDC::AbortDoc Encerra o trabalho de impressão atual, apagando tudo o que o aplicativo escreveu no dispositivo desde a última chamada da função de membro StartDoc.
CDC::AbortPath Fecha e descarta quaisquer caminhos no contexto do dispositivo.
CDC::AddMetaFileComment Copia o comentário de um buffer para um meta-arquivo de formato aprimorado especificado.
CDC::AlphaBlend Exibe bitmaps que têm pixels transparentes ou semitransparentes.
CDC::AngleArc Desenha um segmento de linha e um arco e move a posição atual para o ponto final do arco.
CDC::Arc Desenha um arco elíptico.
CDC::ArcTo Desenha um arco elíptico. Essa função é semelhante a Arc, exceto que a posição atual é atualizada.
CDC::Attach Anexa um contexto de dispositivo Windows a esse objeto CDC.
CDC::BeginPath Abre um colchete de caminho no contexto do dispositivo.
CDC::BitBlt Copia um bitmap de um contexto de dispositivo especificado.
CDC::Chord Desenha uma corda (uma figura fechada delimitada pela interseção de uma elipse e um segmento de linha).
CDC::CloseFigure Fecha uma figura aberta em um caminho.
CDC::CreateCompatibleDC Cria um contexto de dispositivo de memória compatível com outro contexto de dispositivo. Você pode usá-lo para preparar imagens na memória.
CDC::CreateDC Criar um contexto de dispositivo para um dispositivo específico.
CDC::CreateIC Cria um contexto de informações para um dispositivo específico. Isso fornece uma maneira rápida de obter informações sobre o dispositivo sem criar um contexto de dispositivo.
CDC::DeleteDC Exclui o contexto do dispositivo Windows associado a esse objeto CDC.
CDC::DeleteTempMap Chamado pelo manipulador de tempo ocioso CWinApp para excluir qualquer objeto CDC temporário criado por FromHandle. Também desanexa o contexto do dispositivo.
CDC::Detach Desanexa o contexto do dispositivo Windows desse objeto CDC.
CDC::DPtoHIMETRIC Converte unidades de dispositivo em unidades HIMETRIC.
CDC::DPtoLP Converte unidades de dispositivo em unidades lógicas.
CDC::Draw3dRect Desenha um retângulo tridimensional.
CDC::DrawDragRect Apaga e redesenha um retângulo à medida que é arrastado.
CDC::DrawEdge Desenha as bordas de um retângulo.
CDC::DrawEscape Acessa recursos de desenho de uma tela de vídeo que não estão disponíveis diretamente por meio da interface de dispositivo gráfico (GDI).
CDC::DrawFocusRect Desenha um retângulo no estilo usado para indicar o foco.
CDC::DrawFrameControl Desenha um controle de quadro.
CDC::DrawIcon Desenha um ícone.
CDC::DrawState Exibe uma imagem e aplica um efeito visual para indicar um estado.
CDC::DrawText Desenha texto formatado no retângulo especificado.
CDC::DrawTextEx Desenha texto formatado no retângulo especificado usando outros formatos.
CDC::Ellipse Desenha uma elipse.
CDC::EndDoc Encerra um trabalho de impressão iniciado pela função de membro StartDoc.
CDC::EndPage Informa ao driver de dispositivo que uma página está terminando.
CDC::EndPath Fecha um colchete de caminho e seleciona o caminho definido pelo colchete no contexto do dispositivo.
CDC::EnumObjects Enumera as canetas e pincéis disponíveis em um contexto de dispositivo.
CDC::Escape Permite que os aplicativos acessem recursos que não estão disponíveis diretamente de um dispositivo específico por meio do GDI. Também permite o acesso a funções de escape do Windows. As chamadas de escape feitas por um aplicativo são traduzidas e enviadas para o driver do dispositivo.
CDC::ExcludeClipRect Cria uma nova área de recorte que consiste na área de recorte existente menos o retângulo especificado.
CDC::ExcludeUpdateRgn Impede o desenho dentro de áreas inválidas de uma janela excluindo uma região atualizada na janela de uma área de recorte.
CDC::ExtFloodFill Preenche uma área com o pincel atual. Fornece mais flexibilidade do que a função de membro CDC::FloodFill.
CDC::ExtTextOut Grava uma cadeia de caracteres em uma região retangular usando a fonte selecionada no atualmente.
CDC::FillPath Fecha as figuras abertas no caminho atual e preenche o interior do caminho usando o pincel atual e o modo de preenchimento de polígono.
CDC::FillRect Preenche um determinado retângulo usando um pincel específico.
CDC::FillRgn Preenche uma região específica com o pincel especificado.
CDC::FillSolidRect Preenche um retângulo com uma cor sólida.
CDC::FlattenPath Transforma as curvas no caminho selecionado no contexto atual do dispositivo e transforma cada curva em uma sequência de linhas.
CDC::FloodFill Preenche uma área com o pincel atual.
CDC::FrameRect Desenha uma borda em torno de um retângulo.
CDC::FrameRgn Desenha uma borda em torno de uma região específica usando um pincel.
CDC::FromHandle Retorna um ponteiro para um objeto CDC quando dado um identificador para um contexto de dispositivo. Se um objeto CDC não estiver anexado ao identificador, um objeto temporário CDC será criado e anexado.
CDC::GetArcDirection Retorna a direção do arco atual para o contexto do dispositivo.
CDC::GetAspectRatioFilter Recupera a configuração do filtro de taxa de proporção atual.
CDC::GetBkColor Recupera a cor do segundo plano atual.
CDC::GetBkMode Recupera o modo em segundo plano.
CDC::GetBoundsRect Retorna o retângulo delimitador acumulado atual para o contexto do dispositivo especificado.
CDC::GetBrushOrg Recupera a origem do pincel atual.
CDC::GetCharABCWidths Recupera as larguras, em unidades lógicas, de caracteres consecutivos em um determinado intervalo da fonte atual.
CDC::GetCharABCWidthsI Recupera as larguras, em unidades lógicas, de índices de glifo consecutivos em um intervalo especificado da fonte TrueType atual.
CDC::GetCharacterPlacement Recupera vários tipos de informações em uma cadeia de caracteres.
CDC::GetCharWidth Recupera as larguras fracionais de caracteres consecutivos em um determinado intervalo da fonte atual.
CDC::GetCharWidthI Recupera as larguras, em coordenadas lógicas, de índices de glifo consecutivos em um intervalo especificado da fonte atual.
CDC::GetClipBox Recupera as dimensões do retângulo delimitador mais apertado ao redor do limite de recorte atual.
CDC::GetColorAdjustment Recupera os valores de ajuste de cor para o contexto do dispositivo.
CDC::GetCurrentBitmap Retorna um ponteiro para o objeto CBitmap selecionado atualmente.
CDC::GetCurrentBrush Retorna um ponteiro para o objeto CBrush selecionado atualmente.
CDC::GetCurrentFont Retorna um ponteiro para o objeto CFont selecionado atualmente.
CDC::GetCurrentPalette Retorna um ponteiro para o objeto CPalette selecionado atualmente.
CDC::GetCurrentPen Retorna um ponteiro para o objeto CPen selecionado atualmente.
CDC::GetCurrentPosition Recupera a posição atual da caneta (em coordenadas lógicas).
CDC::GetDCBrushColor Recupera a cor atual do pincel.
CDC::GetDCPenColor Recupera a cor atual da caneta.
CDC::GetDeviceCaps Recupera um tipo especificado de informações específicas do dispositivo sobre os recursos de um determinado dispositivo de exibição.
CDC::GetFontData Recupera informações de métrica de fonte de um arquivo de fonte escalonável. As informações a serem recuperadas são identificadas especificando um deslocamento para o arquivo de fonte e o comprimento das informações a serem retornadas.
CDC::GetFontLanguageInfo Retorna informações sobre a fonte selecionada no momento para o contexto de exibição especificado.
CDC::GetGlyphOutline Recupera a curva da estrutura de tópicos ou o bitmap para um caractere de estrutura de tópicos na fonte atual.
CDC::GetGraphicsMode Recupera o modo gráfico atual para o contexto do dispositivo especificado.
CDC::GetHalftoneBrush Recupera um pincel de meio tom.
CDC::GetKerningPairs Recupera os pares de kerning de caracteres para a fonte selecionada no momento no contexto do dispositivo especificado.
CDC::GetLayout Recupera o layout de um contexto de dispositivo (DC). O layout pode ser da esquerda para a direita (padrão) ou da direita para a esquerda (espelhado).
CDC::GetMapMode Recupera o modo de mapeamento atual.
CDC::GetMiterLimit Retorna o limite de malhete para o contexto do dispositivo.
CDC::GetNearestColor Recupera a cor lógica mais próxima de uma cor lógica especificada que o dispositivo determinado pode representar.
CDC::GetOutlineTextMetrics Recupera informações de métrica de fonte para fontes TrueType.
CDC::GetOutputCharWidth Recupera as larguras de caracteres individuais em um grupo consecutivo de caracteres da fonte atual usando o contexto do dispositivo de saída.
CDC::GetOutputTabbedTextExtent Calcula a largura e a altura de uma cadeia de caracteres no contexto do dispositivo de saída.
CDC::GetOutputTextExtent Calcula a largura e a altura de uma linha de texto no contexto do dispositivo de saída usando a fonte atual para determinar as dimensões.
CDC::GetOutputTextMetrics Recupera as métricas da fonte atual do contexto do dispositivo de saída.
CDC::GetPath Recupera as coordenadas que definem os pontos de extremidade das linhas e os pontos de controle das curvas encontradas no caminho selecionado no contexto do dispositivo.
CDC::GetPixel Recupera o valor de cor RGB do pixel no ponto especificado.
CDC::GetPolyFillMode Recupera o modo de preenchimento de polígono atual.
CDC::GetROP2 Recupera o modo de desenho atual.
CDC::GetSafeHdc Retorna CDC::m_hDC, o contexto do dispositivo de saída.
CDC::GetStretchBltMode Recupera o modo de alongamento de bitmap atual.
CDC::GetTabbedTextExtent Calcula a largura e a altura de uma cadeia de caracteres no contexto do dispositivo de atributo.
CDC::GetTextAlign Recupera os sinalizadores de alinhamento de texto.
CDC::GetTextCharacterExtra Recupera a configuração atual para a quantidade de espaçamento entre caracteres.
CDC::GetTextColor Recupera a cor do texto atual.
CDC::GetTextExtent Calcula a largura e a altura de uma linha de texto no contexto do dispositivo de atributo usando a fonte atual para determinar as dimensões.
CDC::GetTextExtentExPointI Recupera o número de caracteres em uma cadeia de caracteres especificada que se ajustará a um espaço especificado e preenche uma matriz com a extensão de texto para cada um desses caracteres.
CDC::GetTextExtentPointI Recupera a largura e a altura da matriz especificada de índices de glifo.
CDC::GetTextFace Copia o nome de tipo da fonte atual em um buffer como uma cadeia de caracteres terminada em nulo.
CDC::GetTextMetrics Recupera as métricas da fonte atual do contexto do dispositivo de atributo.
CDC::GetViewportExt Recupera as extensões x e y do visor.
CDC::GetViewportOrg Recupera as coordenadas x e y da origem do visor.
CDC::GetWindow Retorna a janela associada ao contexto do dispositivo de exibição.
CDC::GetWindowExt Recupera as extensões x e y da janela associada.
CDC::GetWindowOrg Recupera as coordenadas x e y da origem da janela associada.
CDC::GetWorldTransform Recupera o espaço do mundo atual para a transformação de espaço de página.
CDC::GradientFill Preenche estruturas de retângulo e triângulo com uma cor de classificação.
CDC::GrayString Desenha texto esmaecido (acinzentado) no local especificado.
CDC::HIMETRICtoDP Converte unidades HIMETRIC em unidades de dispositivo.
CDC::HIMETRICtoLP Converte unidades HIMETRIC em unidades lógicas.
CDC::IntersectClipRect Cria uma nova área de recorte formando a interseção da região atual e um retângulo.
CDC::InvertRect Inverte o conteúdo de um retângulo.
CDC::InvertRgn Inverte as cores em uma região.
CDC::IsPrinting Determina se o contexto do dispositivo está sendo usado para impressão.
CDC::LineTo Desenha uma linha da posição atual até, mas não incluindo, um ponto.
CDC::LPtoDP Converte unidades lógicas em unidades de dispositivo.
CDC::LPtoHIMETRIC Converte unidades lógicas em unidades HIMETRIC.
CDC::MaskBlt Combina os dados de cor para os bitmaps de origem e destino usando a operação de máscara e varredura dados.
CDC::ModifyWorldTransform Altera a transformação do mundo para um contexto de dispositivo usando o modo especificado.
CDC::MoveTo Move a posição atual.
CDC::OffsetClipRgn Move a área de recorte do dispositivo especificado.
CDC::OffsetViewportOrg Modifica a origem do visor em relação às coordenadas da origem do visor atual.
CDC::OffsetWindowOrg Modifica a origem da janela em relação às coordenadas da origem da janela atual.
CDC::PaintRgn Preenche uma região com o pincel selecionado.
CDC::PatBlt Cria um padrão de bit.
CDC::Pie Desenha uma borda em forma de torta.
CDC::PlayMetaFile Reproduz o conteúdo do meta-arquivo especificado no dispositivo especificado. A versão aprimorada de PlayMetaFile exibe a imagem armazenada no meta-arquivo de formato aprimorado especificado. O meta-arquivo pode ser reproduzido várias vezes.
CDC::PlgBlt Executa uma transferência de bloco de bits dos bits de dados de cor do retângulo especificado no contexto do dispositivo de origem para o paralelograma especificado no contexto de dispositivo fornecido.
CDC::PolyBezier Desenha um ou mais splines Bzier. A posição atual não é usada ou atualizada.
CDC::PolyBezierTo Desenha um ou mais splines Bzier, e move a posição atual para o ponto final do último spline Bzier.
CDC::PolyDraw Desenha um conjunto de segmentos de linha e splines Bzier. Essa função atualiza a posição atual.
CDC::Polygon Desenha um polígono que consiste em dois ou mais pontos (vértices) conectados por linhas.
CDC::Polyline Desenha um conjunto de segmentos de linha que conectam os pontos especificados.
CDC::PolylineTo Desenha uma ou mais linas retas, e move a posição atual para o ponto final da última linha.
CDC::PolyPolygon Cria dois ou mais polígonos que são preenchidos usando o modo de preenchimento de polígono atual. Os polígonos podem ser desarticulados ou podem se sobrepor.
CDC::PolyPolyline Desenha várias séries de segmentos de linha conectados. A posição atual não é usada ou atualizada por esta função.
CDC::PtVisible Especifica se o ponto determinado está dentro da área de recorte.
CDC::RealizePalette Mapeia as entradas de paleta na paleta lógica atual para a paleta do sistema.
CDC::Rectangle Desenha um retângulo usando a caneta atual e a preenche usando o pincel atual.
CDC::RectVisible Determina se alguma parte do retângulo determinado está dentro da área de recorte.
CDC::ReleaseAttribDC Libera m_hAttribDC, o contexto de dispositivo de atributo.
CDC::ReleaseOutputDC Libera m_hDC, o contexto de dispositivo de saída.
CDC::ResetDC Atualiza o contexto de dispositivo m_hAttribDC.
CDC::RestoreDC Restaura o contexto de dispositivo para um estado anterior salvo com SaveDC.
CDC::RoundRect Desenha um retângulo com cantos arredondados usando a caneta atual e preenchido usando o pincel atual.
CDC::SaveDC Salva o estado atual do contexto de dispositivo.
CDC::ScaleViewportExt Modifica a extensão do visor em relação aos valores atuais.
CDC::ScaleWindowExt Modifica as extensões de janela relativas aos valores atuais.
CDC::ScrollDC Percorre um retângulo de bits horizontal e verticalmente.
CDC::SelectClipPath Seleciona o caminho atual como uma área de recorte para o contexto do dispositivo, combinando a nova área com qualquer área de recorte existente usando o modo especificado.
CDC::SelectClipRgn Combina a área fornecida com a área de recorte atual usando o modo especificado.
CDC::SelectObject Seleciona um objeto de desenho de GDI, como uma caneta.
CDC::SelectPalette Seleciona a paleta lógica.
CDC::SelectStockObject Seleciona uma das canetas de estoque predefinidas, pincéis ou fontes fornecidas pelo Windows.
CDC::SetAbortProc Define uma função de retorno de chamada fornecida pelo programador que o Windows chama se um trabalho de impressão precisar ser anulado.
CDC::SetArcDirection Define a direção do desenho a ser usada para funções de arco e retângulo.
CDC::SetAttribDC Define m_hAttribDC, o contexto de dispositivo de atributo.
CDC::SetBkColor Define a cor do segundo plano atual.
CDC::SetBkMode Define o modo em segundo plano.
CDC::SetBoundsRect Controla o acúmulo de informações delimitador-retângulo para o contexto do dispositivo especificado.
CDC::SetBrushOrg Especifica a origem do próximo pincel selecionado em um contexto de dispositivo.
CDC::SetColorAdjustment Define os valores de ajuste de cor para o contexto do dispositivo usando os valores especificados.
CDC::SetDCBrushColor Define a cor atual do pincel.
CDC::SetDCPenColor Define a cor atual da caneta.
CDC::SetGraphicsMode Define o modo gráfico atual para o contexto do dispositivo especificado.
CDC::SetLayout Altera o layout de um contexto de dispositivo (DC).
CDC::SetMapMode Define o modo de mapeamento atual.
CDC::SetMapperFlags Altera o algoritmo que o mapeador de fontes usa quando mapeia fontes lógicas para fontes físicas.
CDC::SetMiterLimit Define o limite para o comprimento das junções de malhete para o contexto de dispositivo.
CDC::SetOutputDC Define m_hDC, o contexto do dispositivo de saída.
CDC::SetPixel Define o pixel no ponto especificado como a aproximação mais próxima da cor especificada.
CDC::SetPixelV Define o pixel nas coordenadas especificadas como a aproximação mais próxima da cor especificada. SetPixelV é mais rápido do que SetPixel porque não precisa retornar o valor de cor do ponto pintado.
CDC::SetPolyFillMode Define o modo de preenchimento de polígono.
CDC::SetROP2 Define o modo de desenho atual.
CDC::SetStretchBltMode Define o modo de alongamento de bitmap.
CDC::SetTextAlign Define os sinalizadores de alinhamento de texto.
CDC::SetTextCharacterExtra Define a quantidade de espaçamento entre caracteres.
CDC::SetTextColor Define a cor do texto.
CDC::SetTextJustification Adiciona espaço aos caracteres de quebra em uma cadeia de caracteres.
CDC::SetViewportExt Define as extensões x e y do visor.
CDC::SetViewportOrg Define a origem do visor.
CDC::SetWindowExt Define as extensões x e y da janela associada.
CDC::SetWindowOrg Define a origem da janela do contexto do dispositivo.
CDC::SetWorldTransform Define o espaço do mundo atual para a transformação de espaço de página.
CDC::StartDoc Informa ao driver do dispositivo que um novo trabalho de impressão está sendo iniciado.
CDC::StartPage Informa ao driver do dispositivo que uma nova página está sendo iniciada.
CDC::StretchBlt Move um bitmap de um retângulo de origem e um dispositivo para um retângulo de destino, alongando-o ou compactando-o, se necessário, para ajustá-lo às dimensões do retângulo de destino.
CDC::StrokeAndFillPath Fecha as figuras abertas em um caminho, atinge a estrutura de tópicos do caminho usando a caneta atual e preenche seu interior usando o pincel atual.
CDC::StrokePath Renderiza o caminho especificado usando a caneta atual.
CDC::TabbedTextOut Grava uma cadeia de caracteres em um local especificado, expandindo guias para os valores especificados em uma matriz de posições tab-stop.
CDC::TextOut Grava uma cadeia de caracteres em um local especificado usando a fonte selecionada no momento.
CDC::TransparentBlt Transfere um bloco de bits de dados de cor do contexto do dispositivo de origem especificado para um contexto de dispositivo de destino, renderizando uma cor especificada transparente na transferência.
CDC::UpdateColors Atualiza a área do cliente do contexto do dispositivo, combinando as cores atuais na área do cliente com a paleta do sistema em uma base pixel a pixel.
CDC::WidenPath Redefine o caminho atual como a área que seria pintada se o caminho fosse traçado usando a caneta selecionada atualmente no contexto do dispositivo.

Operadores públicos

Nome Descrição
CDC::operator HDC Recupera o identificador do contexto do dispositivo.

Membros de Dados Públicos

Nome Descrição
CDC::m_hAttribDC O contexto atributo-dispositivo usado por esse objeto CDC.
CDC::m_hDC O contexto saída-dispositivo usado por esse objeto CDC.

Comentários

O CDC objeto fornece funções de membro para trabalhar com um contexto de dispositivo, como um monitor ou impressora, e membros para trabalhar com um contexto de exibição associado à área do cliente de uma janela.

Faça todo o desenho pelas funções de membro de um objeto CDC. A classe fornece funções membro para operações de contexto de dispositivo, trabalhando com ferramentas de desenho, seleção de objeto GDI (interface de dispositivo gráfico) com segurança de tipo e trabalhando com cores e paletas. Ele também fornece funções membros para obter e definir atributos de desenho, mapeamento, trabalhar com o visor, trabalhar com a extensão da janela, converter coordenadas, trabalhar com regiões, recortes, linhas de desenho e desenhar formas simples, elipses e polígonos. As funções membro também são fornecidas para desenhar texto, trabalhar com fontes, usar escapes de impressora, rolagem e reprodução de meta-arquivos.

Para usar um objeto CDC, construa-o e, em seguida, chame suas funções de membro que funções paralelas do Windows que usam contextos de dispositivo.

Observação

No Windows 95/98, todas as coordenadas de tela são limitadas a 16 bits. Portanto, um int passado para uma função de membro CDC deve estar no intervalo -32768 a 32767.

Para usos específicos, a Biblioteca de classes do Microsoft Foundation fornece várias classes derivadas de CDC. CPaintDC encapsula chamadas para BeginPaint e EndPaint. CClientDC gerencia um contexto de exibição associado à área de cliente de uma janela. CWindowDC gerencia um contexto de exibição associado a uma janela inteira, incluindo seu quadro e controles. CMetaFileDC associa um contexto de dispositivo a um meta-arquivo.

CDC fornece duas funções GetLayout de membro e SetLayout, para reverter o layout de um contexto de dispositivo, que não herda seu layout de uma janela. Essa orientação da direita para a esquerda é necessária para aplicativos escritos para culturas, como árabe ou hebraico, onde o layout de caracteres não é o padrão europeu.

CDC contém dois contextos de dispositivo, m_hDC e m_hAttribDC que, na criação de um objeto CDC, referem-se ao mesmo dispositivo. CDC direciona todas as chamadas GDI de saída para m_hDC e a maioria das chamadas GDI de atributo para m_hAttribDC. (Um exemplo de uma chamada de atributo é GetTextColor, enquanto SetTextColor é uma chamada de saída.)

Por exemplo, a estrutura usa esses dois contextos de dispositivo para implementar um objeto CMetaFileDC que enviará a saída para um meta-arquivo durante a leitura de atributos de um dispositivo físico. A visualização de impressão é implementada na estrutura de forma semelhante. Você também pode usar os dois contextos de dispositivo de maneira semelhante no código específico do aplicativo.

Há ocasiões em que você pode precisar de informações de métrica de texto dos contextos de dispositivo m_hDC e m_hAttribDC. Os seguintes pares de funções fornecem essa funcionalidade:

Usa m_hAttribDC Usa m_hDC
GetTextExtent GetOutputTextExtent
GetTabbedTextExtent GetOutputTabbedTextExtent
GetTextMetrics GetOutputTextMetrics
GetCharWidth GetOutputCharWidth

Para mais informações sobre CDC, confira Contextos de dispositivo.

Hierarquia de herança

CObject

CDC

Requisitos

Cabeçalhoafxwin.h:

CDC::AbortDoc

Encerra o trabalho de impressão atual e apaga tudo o que o aplicativo escreveu no dispositivo desde a última chamada para a função de membro StartDoc.

int AbortDoc();

Valor de Devolução

Um valor maior ou igual a 0 se tiver êxito ou um valor negativo se ocorreu um erro. A lista a seguir mostra valores de erro comuns e seus significados:

  • SP_ERROR Erro geral.

  • SP_OUTOFDISK No momento, não há espaço em disco suficiente disponível para spooling e não haverá mais espaço disponível.

  • SP_OUTOFMEMORY Não há memória suficiente disponível para spooling.

  • SP_USERABORT O usuário encerrou o trabalho por meio do Gerenciador de impressão.

Comentários

Essa função membro substitui o escape da impressora ABORTDOC.

AbortDoc deve ser usado para encerrar o seguinte:

  • Operações de impressão que não especificam uma função de interrupção usando SetAbortProco .

  • Operações de impressão que ainda não atingiram sua primeira chamada de escape NEWFRAME ou NEXTBAND.

Se um aplicativo encontrar um erro de impressão ou uma operação de impressão cancelada, ele não deverá tentar encerrar a operação usando as funções ou as funções de membro EndDoc ou AbortDoc da classe CDC. A GDI encerra automaticamente a operação antes de retornar o valor de erro.

Se o aplicativo exibir uma caixa de diálogo para permitir que o usuário cancele a operação de impressão, ele deverá chamar AbortDoc antes de destruir a caixa de diálogo.

Se o Gerenciador de Impressão foi usado para iniciar o trabalho de impressão, a chamada AbortDoc apaga todo o trabalho de spool — a impressora não recebe nada. Se o Gerenciador de Impressão não foi usado para iniciar o trabalho de impressão, os dados podem ter sido enviados para a impressora antes AbortDoc de serem chamados. Nesse caso, o driver da impressora teria redefinido a impressora (quando possível) e fechado o trabalho de impressão.

Exemplo

Confira o exemplo de CDC::StartDoc.

CDC::AbortPath

Fecha e descarta quaisquer caminhos no contexto do dispositivo.

BOOL AbortPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Se houver um colchete de caminho aberto no contexto do dispositivo, o colchete de caminho será fechado e o caminho será descartado. Se houver um caminho fechado no contexto do dispositivo, o caminho será descartado.

CDC::AddMetaFileComment

Copia o comentário de um buffer para um meta-arquivo de formato aprimorado especificado.

BOOL AddMetaFileComment(
    UINT nDataSize,
    const BYTE* pCommentData);

Parâmetros

nDataSize
E especifica o comprimento do buffer de comentário em bytes.

pCommentData
Aponta para o buffer que contém o comentário.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Um comentário pode incluir qualquer informação privada, por exemplo, a origem da imagem e a data em que ela foi criada. Um comentário deve começar com uma assinatura de aplicativo, seguida pelos dados. Os comentários não devem conter dados específicos da posição. Os dados específicos da posição especificam o local de um registro e não devem ser incluídos porque um metarquivo pode ser incorporado em outro metarquivo. Essa função só pode ser usada com meta-arquivos aprimorados.

CDC::AlphaBlend

Chame essa função de membro para exibir bitmaps com pixels transparentes ou semitransparentes.

BOOL AlphaBlend(
    int xDest,
    int yDest,
    int nDestWidth,
    int nDestHeight,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    int nSrcWidth,
    int nSrcHeight,
    BLENDFUNCTION blend);

Parâmetros

xDest
Especifica a coordenada x, em unidades lógicas, do canto esquerdo superior do retângulo de destino.

yDest
Especifica a coordenada y, em unidades lógicas, do canto esquerdo superior do retângulo de destino.

nDestWidth
Especifica a largura, em unidades lógicas, do retângulo de destino.

nDestHeight
Especifica a altura, em unidades lógicas, do retângulo de destino.

pSrcDC
Um ponteiro para o contexto de dispositivo de origem.

xSrc
Especifica a coordenada x, em unidades lógicas, do canto esquerdo superior do retângulo de origem.

ySrc
Especifica a coordenada y, em unidades lógicas, do canto esquerdo superior do retângulo de origem.

nSrcWidth
Especifica a largura, em unidades lógicas, do retângulo de origem.

nSrcHeight
Especifica a altura, em unidades lógicas, do retângulo de origem.

blend
Especifica uma estrutura BLENDFUNCTION.

Valor de Devolução

TRUE se for bem-sucedido, caso contrário, FALSE.

Comentários

Confira AlphaBlend no SDK do Windows para mais informações.

CDC::AngleArc

Desenha um segmento de linha e um arco.

BOOL AngleArc(
    int x,
    int y,
    int nRadius,
    float fStartAngle,
    float fSweepAngle);

Parâmetros

x
Especifica a coordenada x lógica do centro do círculo.

y
Especifica a coordenada y lógica do centro do círculo.

nRadius
Especifica o raio do círculo em unidades lógicas. Esse valor deve ser positivo.

fStartAngle
Especifica o ângulo inicial em graus relativos ao eixo x.

fSweepAngle
Especifica o ângulo de varredura em graus em relação ao ângulo inicial.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

O segmento de linha é desenhado da posição atual para o início do arco. O arco é desenhado ao longo do perímetro de um círculo com o raio e o centro determinados. O comprimento do arco é definido pelos ângulos de início e varredura fornecidos.

AngleArc move a posição atual para o ponto final do arco. O arco desenhado por essa função pode parecer elíptico, dependendo do modo de transformação e mapeamento atual. Antes de desenhar o arco, essa função desenha o segmento de linha da posição atual até o início do arco. O arco é desenhado pela construção de um círculo imaginário com o raio especificado ao redor do ponto central especificado. O ponto de partida do arco é determinado medindo no sentido anti-horário do eixo x do círculo pelo número de graus no ângulo inicial. O ponto final é localizado da mesma forma medindo no sentido anti-horário do ponto de partida pelo número de graus no ângulo de varredura.

Se o ângulo de varredura for maior que 360 graus, o arco será varrido várias vezes. Essa função desenha linhas usando a caneta atual. O número não está preenchido.

CDC::Arc

Desenha um arco elíptico.

BOOL Arc(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3,
    int x4,
    int y4);

BOOL Arc(
    LPCRECT lpRect,
    POINT ptStart,
    POINT ptEnd);

Parâmetros

x1
Especifica a coordenada x do canto esquerdo superior do retângulo delimitador (em unidades lógicas).

y1
Especifica a coordenada y do canto esquerdo superior do retângulo delimitador (em unidades lógicas).

x2
Especifica a coordenada x do canto direito inferior do retângulo delimitador (em unidades lógicas).

y2
Especifica a coordenada y do canto direito inferior do retângulo delimitador (em unidades lógicas).

x3
Especifica a coordenada x do ponto que define o ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

y3
Especifica a coordenada y do ponto que define o ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

x4
Especifica a coordenada x do ponto que define o ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

y4
Especifica a coordenada y do ponto que define o ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

lpRect
Especifica o retângulo delimitador (em unidades lógicas). Você pode passar um objeto LPRECT ou CRect para esse parâmetro.

ptStart
Especifica as coordenadas x e y do ponto que define o ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco. Você pode passar uma POINT estrutura ou um CPoint objeto para esse parâmetro.

ptEnd
Especifica as coordenadas x e y do ponto que define o ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco. Você pode passar uma POINT estrutura ou um CPoint objeto para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O arco desenhado usando a função é um segmento da elipse definido pelo retângulo delimitador especificado.

O ponto de partida real do arco é o ponto em que um raio extraído do centro do retângulo delimitador através do ponto de partida especificado cruza a elipse. O ponto final real do arco é o ponto em que um raio extraído do centro do retângulo delimitador através do ponto final especificado cruza a elipse. O arco é desenhado em uma direção no sentido anti-horário. Como um arco não é uma figura fechada, ele não é preenchido. A largura e a altura do retângulo devem ser maiores que 2 unidades e menos de 32.767 unidades.

Exemplo

void CDCView::DrawArc(CDC *pDC)
{
   // Fill the client area with a thin circle. The circle's
   // interior is not filled. The circle's perimeter is
   // blue from 6 o'clock to 3 o'clock and red from 3
   // o'clock to 6 o'clock.

   // Get the client area.
   CRect rectClient;
   GetClientRect(rectClient);

   // Make a couple of pens.
   CPen penBlue;
   CPen penRed;
   CPen *pOldPen;

   penBlue.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(0, 0, 255));
   penRed.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(255, 0, 0));

   // Draw from 3 o'clock to 6 o'clock, counterclockwise,
   // in a blue pen.

   pOldPen = pDC->SelectObject(&penBlue);

   pDC->Arc(rectClient,
            CPoint(rectClient.right, rectClient.CenterPoint().y),
            CPoint(rectClient.CenterPoint().x, rectClient.right));

   // Draw from 6 o'clock to 3 o'clock, counterclockwise,
   // in a red pen.
   pDC->SelectObject(&penRed);

   // Keep the same parameters, but reverse start
   // and end points.
   pDC->Arc(rectClient,
            CPoint(rectClient.CenterPoint().x, rectClient.right),
            CPoint(rectClient.right, rectClient.CenterPoint().y));

   // Restore the previous pen.
   pDC->SelectObject(pOldPen);
}

CDC::ArcTo

Desenha um arco elíptico.

BOOL ArcTo(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3,
    int x4,
    int y4);

BOOL ArcTo(
    LPCRECT lpRect,
    POINT ptStart,
    POINT ptEnd);

Parâmetros

x1
Especifica a coordenada x do canto esquerdo superior do retângulo delimitador (em unidades lógicas).

y1
Especifica a coordenada y do canto esquerdo superior do retângulo delimitador (em unidades lógicas).

x2
Especifica a coordenada x do canto direito inferior do retângulo delimitador (em unidades lógicas).

y2
Especifica a coordenada y do canto direito inferior do retângulo delimitador (em unidades lógicas).

x3
Especifica a coordenada x do ponto que define o ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

y3
Especifica a coordenada y do ponto que define o ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

x4
Especifica a coordenada x do ponto que define o ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

y4
Especifica a coordenada y do ponto que define o ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

lpRect
Especifica o retângulo delimitador (em unidades lógicas). Você pode passar um ponteiro para uma estrutura de dados RECT ou um objeto CRect para esse parâmetro.

ptStart
Especifica as coordenadas x e y do ponto que define o ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco. Você pode passar uma estrutura de POINT dados ou um CPoint objeto para esse parâmetro.

ptEnd
Especifica as coordenadas x e y do ponto que define o ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco. Você pode passar uma estrutura de POINT dados ou um CPoint objeto para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função é semelhante a CDC::Arc, exceto que a posição atual é atualizada. Os pontos (x1, y1) e (x2, y2) especificam o retângulo delimitador. Uma elipse formada pelo retângulo delimitador especificado define a curva do arco. O arco estende-se no sentido anti-horário (a direção padrão do arco) do ponto em que cruza a linha radial do centro do retângulo delimitador para ( *x3*, y3). O arco termina onde cruza a linha radial do centro do retângulo delimitador para (x4, y4). Se o ponto de partida e o ponto final forem os mesmos, uma elipse completa será desenhada.

Uma linha é traçada da posição atual até o ponto inicial do arco. Se nenhum erro ocorrer, a posição atual será definida como o ponto final do arco. O arco é desenhado usando a caneta atual; não está cheio.

CDC::Attach

Use essa função de membro para anexar um hDC ao objeto CDC.

BOOL Attach(HDC hDC);

Parâmetros

hDC
O contexto de dispositivo Windows.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O hDC é armazenada em ambos, m_hDC no contexto do dispositivo de saída e em m_hAttribDC, o contexto de dispositivo de atributo.

CDC::BeginPath

Abre um colchete de caminho no contexto do dispositivo.

BOOL BeginPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Depois que um colchete de caminho é aberto, um aplicativo pode começar a chamar funções de desenho GDI para definir os pontos que estão no caminho. Um aplicativo pode fechar um colchete de caminho aberto chamando a função de membro EndPath. Quando um aplicativo chama BeginPath, todos os caminhos anteriores são descartados.

Consulte BeginPath no SDK do Windows uma lista das funções de desenho que definem pontos em um caminho.

Exemplo

// This implementation uses GDI paths to draw the outline of
// some text in a TrueType font. The path is used to record the way
// the TrueType font would be drawn. Then, the function uses the data
// returned from CDC::GetPath() to draw the font--without filling it.
void CDCView::DrawPath(CDC *pDC)
{
   // Describe a 24-point truetype font of normal weight
   LOGFONT lf;
   memset(&lf, 0, sizeof(lf));
   lf.lfHeight = -MulDiv(24, pDC->GetDeviceCaps(LOGPIXELSY), 72);
   lf.lfWeight = FW_NORMAL;
   lf.lfOutPrecision = OUT_TT_ONLY_PRECIS;

   // create and select it
   CFont newFont;
   if (!newFont.CreateFontIndirect(&lf))
      return;
   CFont *pOldFont = pDC->SelectObject(&newFont);

   // use a path to record how the text was drawn
   pDC->BeginPath();
   pDC->TextOut(10, 10, _T("Outline this!"));
   pDC->EndPath();

   // Find out how many points are in the path. Note that
   // for long strings or complex fonts, this number might be
   // gigantic!
   int nNumPts = pDC->GetPath(NULL, NULL, 0);
   if (nNumPts == 0)
      return;

   // Allocate memory to hold points and stroke types from
   // the path.
   LPPOINT lpPoints = NULL;
   LPBYTE lpTypes = NULL;
   try
   {
      lpPoints = new POINT[nNumPts];
      lpTypes = new BYTE[nNumPts];
   }
   catch (CException *pe)
   {
      delete[] lpPoints;
      lpPoints = NULL;
      delete[] lpTypes;
      lpTypes = NULL;
      pe->Delete();
   }
   if (lpPoints == NULL || lpTypes == NULL)
      return;

   // Now that we have the memory, really get the path data.
   nNumPts = pDC->GetPath(lpPoints, lpTypes, nNumPts);

   // If it worked, draw the lines. Windows 98 doesn't support
   // the PolyDraw API, so we use our own member function to do
   // similar work. If you're targeting only later versions of
   // Windows, you can use the PolyDraw() API and avoid the
   // COutlineView::PolyDraw() member function.

   if (nNumPts != -1)
      pDC->PolyDraw(lpPoints, lpTypes, nNumPts);

   // Release the memory we used
   delete[] lpPoints;
   delete[] lpTypes;

   // Put back the old font
   pDC->SelectObject(pOldFont);

   return;
}

CDC::BitBlt

Copia um bitmap do contexto do dispositivo de origem para este contexto de dispositivo atual.

BOOL BitBlt(
    int x,
    int y,
    int nWidth,
    int nHeight,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    DWORD dwRop);

Parâmetros

x
Especifica a coordenada x lógica do canto superior esquerdo do retângulo de destino.

y
Especifica a coordenada y lógica do canto superior esquerdo do retângulo de destino.

nWidth
Especifica a largura (em unidades lógicas) do retângulo de destino e do bitmap de origem.

nHeight
Especifica a altura (em unidades lógicas) do retângulo de destino e do bitmap de origem.

pSrcDC
Ponteiro para um objeto CDC que identifica o contexto do dispositivo do qual o bitmap será copiado. Deve ser NULL se dwRop especificar uma operação raster que não inclua uma origem.

xSrc
Especifica a coordenada x lógica do canto superior esquerdo do bitmap de origem.

ySrc
Especifica a coordenada y lógica do canto superior esquerdo do bitmap de origem.

dwRop
Especifica a operação de varredura a ser executada. Os códigos da operação de varredura definem como a GDI combina cores nas operações de saída que envolvem um pincel, um possível bitmap de origem e um bitmap de destino. Confira BitBlt no SDK do Windows para obter uma lista de outros códigos de operação de varredura para dwRop e suas descrições.

Para obter uma lista completa de códigos de operação raster, consulte Sobre códigos de Sobre Códigos de operação de varredura no SDK do Windows.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O aplicativo pode alinhar as áreas do cliente ou janelas em limites de bytes para garantir que as operações BitBlt ocorram em retângulos alinhados a bytes. (Defina os sinalizadores CS_BYTEALIGNWINDOW ou CS_BYTEALIGNCLIENT ao registrar as classes de janela.)

BitBlt As operações em retângulos alinhados a bytes são consideravelmente mais rápidas do que BitBlt as operações em retângulos que não estão alinhados a bytes. Se você quiser especificar estilos de classe, como alinhamento de bytes, para seu próprio contexto de dispositivo, precisará registrar uma classe de janela em vez de depender das classes do Microsoft Foundation para fazer isso por você. Use a função global AfxRegisterWndClass.

A GDI transforma nWidth e nHeight, uma vez, usando o contexto do dispositivo de destino e uma vez usando o contexto do dispositivo de origem. Se as extensões resultantes não corresponderem, o GDI usará a função do Windows StretchBlt para compactar ou esticar o bitmap de origem conforme necessário.

Se os bitmaps de destino, origem e padrão não tiverem o mesmo formato de cor, a BitBlt função converterá os bitmaps de origem e padrão para corresponder ao destino. As cores do primeiro e do segundo plano do bitmap de destino são usadas na conversão.

Quando a função BitBlt converte um bitmap monocromático em colorido, ele definirá bits brancos (1) para a cor do plano de fundo e bits pretos (0) para a cor do primeiro plano. As cores do primeiro plano e do plano de fundo do contexto do dispositivo de destino são usadas. Para converter o colorido em monocromático, BitBlt define pixels que correspondam à cor do plano de fundo para branco e define todos os outros pixels para preto. BitBlt usa as cores de primeiro e de segundo plano do contexto do dispositivo de cores para converter de cor para monocromática.

Nem todos os contextos de dispositivo suportam BitBlt. Para verificar se um determinado contexto de dispositivo dá suporte a BitBlt, use a função de membro GetDeviceCaps e especifique o índice RASTERCAPS.

Exemplo

Confira o exemplo de CDC::CreateCompatibleDC.

CDC::CDC

Constrói um objeto CDC.

CDC();

CDC::Chord

Desenha uma corda (uma figura fechada delimitada pela interseção de uma elipse e um segmento de linha).

BOOL Chord(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3,
    int x4,
    int y4);

BOOL Chord(
    LPCRECT lpRect,
    POINT ptStart,
    POINT ptEnd);

Parâmetros

x1
Especifica a coordenada x do canto esquerdo superior do retângulo delimitador da corda (em unidades lógicas).

y1
Especifica a coordenada y do canto esquerdo superior do retângulo delimitador da corda (em unidades lógicas).

x2
Especifica a coordenada x do canto direito inferior do retângulo delimitador da corda (em unidades lógicas).

y2
Especifica a coordenada y do canto direito inferior do retângulo delimitador da corda (em unidades lógicas).

x3
Especifica a coordenada x do ponto que define o ponto de partida da corda (em unidades lógicas).

y3
Especifica a coordenada y do ponto que define o ponto de partida da corda (em unidades lógicas).

x4
Especifica a coordenada x do ponto que define o ponto final da corda (em unidades lógicas).

y4
Especifica a coordenada y do ponto que define o ponto final da corda (em unidades lógicas).

lpRect
Especifica o retângulo delimitador (em unidades lógicas). Você pode passar um objeto LPRECT ou CRect para esse parâmetro.

ptStart
Especifica as coordenadas x e y do ponto que define o ponto de partida da corda (em unidades lógicas). Esse ponto não precisa estar exatamente no acorde. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

*ptEnd*
Especifica as coordenadas x e y do ponto que define o ponto final da corda (em unidades lógicas). Esse ponto não precisa estar exatamente no acorde. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Os parâmetros ( x1, y1) e ( x2, y2) especificam os cantos superior esquerdo e inferior direito, respectivamente, de um retângulo delimitando a elipse que faz parte da corda. Os parâmetros (x3, y3) e (x4, y4) especificam os pontos de extremidade de uma linha que cruza a elipse. A corda é desenhada usando a caneta selecionada e preenchida usando o pincel selecionado.

A figura desenhada Chord pela função se estende até, mas não inclui as coordenadas direita e inferior. Isso significa que a altura da figura é y2 - y1 e a largura da figura é x2 - x1.

Exemplo

void CDCView::DrawChord(CDC *pDC)
{
   // Fill the client area with a circle. The circle is
   // blue and filled with blue, but has a chord cut out
   // of it from 3 o'clock to 6 o'clock. That chord is
   // red and filled with a red diagonal hatch.

   // Get the client area.
   CRect rectClient;
   GetClientRect(rectClient);

   // Make a couple of pens and similar brushes.
   CPen penBlue, penRed;
   CBrush brushBlue, brushRed;
   CBrush *pOldBrush;
   CPen *pOldPen;

   brushBlue.CreateSolidBrush(RGB(0, 0, 255));
   brushRed.CreateHatchBrush(HS_FDIAGONAL, RGB(255, 0, 0));
   penBlue.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(0, 0, 255));
   penRed.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(255, 0, 0));

   // Draw from 3 o'clock to 6 o'clock, counterclockwise,
   // in a blue pen with a solid blue fill.
   pOldPen = pDC->SelectObject(&penBlue);
   pOldBrush = pDC->SelectObject(&brushBlue);

   pDC->Chord(rectClient,
              CPoint(rectClient.right, rectClient.CenterPoint().y),
              CPoint(rectClient.CenterPoint().x, rectClient.right));

   // Draw the remaining quarter chord from 6 o'clock
   // to 3 o'clock, counterclockwise, in a red pen
   // with the hatched brush.
   pDC->SelectObject(&penRed);
   pDC->SelectObject(&brushRed);

   // Keep the same parameters, but reverse start and
   // end points.
   pDC->Chord(rectClient,
              CPoint(rectClient.CenterPoint().x, rectClient.right),
              CPoint(rectClient.right, rectClient.CenterPoint().y));

   // Restore the previous pen.
   pDC->SelectObject(pOldPen);
}

CDC::CloseFigure

Fecha uma figura aberta em um caminho.

BOOL CloseFigure();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

A função fecha a figura desenhando uma linha da posição atual para o primeiro ponto da figura (geralmente, o ponto especificado pela chamada mais recente para a função de membro MoveTo) e conecta as linhas usando o estilo de junção de linha. Se uma figura for fechada usando a função de membro LineTo em vez de CloseFigure, os arremates de extremidade serão usados para criar o canto em vez de uma junção. CloseFigure só deve ser chamado se houver um colchete de caminho aberto no contexto do dispositivo.

Uma figura em um caminho é aberta, a menos que seja explicitamente fechada usando essa função. (Uma figura pode ser aberta mesmo que o ponto atual e o ponto de partida da figura sejam iguais.) Qualquer linha ou curva adicionada ao caminho após CloseFigure iniciar uma nova figura.

CDC::CreateCompatibleDC

Cria um contexto de dispositivo de memória compatível com outro contexto de dispositivo especificado por pDC.

BOOL CreateCompatibleDC(CDC* pDC);

Parâmetros

pDC
Um ponteiro para um contexto de dispositivo. Se pDC for NULL, a função criará um contexto de dispositivo de memória compatível com a exibição do sistema.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Um contexto de dispositivo de memória é um bloco de memória que representa uma superfície de exibição. Ele pode ser usado para preparar imagens na memória antes de copiá-las para a superfície real do dispositivo compatível.

Quando um contexto de dispositivo de memória é criado, o GDI seleciona automaticamente um bitmap de estoque monocromático 1 por 1 para ele. As funções de saída GDI só poderão ser usadas com um contexto de dispositivo de memória se um bitmap tiver sido criado e selecionado nesse contexto.

Essa função só pode ser usada para criar contextos de dispositivo compatíveis para dispositivos que dão suporte a operações de varredura. Consulte a função de membro CDC::BitBlt para obter informações sobre transferências de bloco de bits entre contextos de dispositivo. Para determinar se um contexto de dispositivo dá suporte a operações de varredura, consulte a funcionalidade de varredura RC_BITBLT na função de membro CDC::GetDeviceCaps.

Exemplo

// This handler loads a bitmap from system resources,
// centers it in the view, and uses BitBlt() to paint the bitmap
// bits.
void CDCView::DrawBitmap(CDC *pDC)
{
   // load IDB_BITMAP1 from our resources
   CBitmap bmp;
   if (bmp.LoadBitmap(IDB_BITMAP1))
   {
      // Get the size of the bitmap
      BITMAP bmpInfo;
      bmp.GetBitmap(&bmpInfo);

      // Create an in-memory DC compatible with the
      // display DC we're using to paint
      CDC dcMemory;
      dcMemory.CreateCompatibleDC(pDC);

      // Select the bitmap into the in-memory DC
      CBitmap *pOldBitmap = dcMemory.SelectObject(&bmp);

      // Find a centerpoint for the bitmap in the client area
      CRect rect;
      GetClientRect(&rect);
      int nX = rect.left + (rect.Width() - bmpInfo.bmWidth) / 2;
      int nY = rect.top + (rect.Height() - bmpInfo.bmHeight) / 2;

      // Copy the bits from the in-memory DC into the on-
      // screen DC to actually do the painting. Use the centerpoint
      // we computed for the target offset.
      pDC->BitBlt(nX, nY, bmpInfo.bmWidth, bmpInfo.bmHeight, &dcMemory,
                  0, 0, SRCCOPY);

      dcMemory.SelectObject(pOldBitmap);
   }
   else
   {
      TRACE0("ERROR: Where's IDB_BITMAP1?\n");
   }
}

CDC::CreateDC

Cria um contexto de dispositivo para o dispositivo especificado.

BOOL CreateDC(
    LPCTSTR lpszDriverName,
    LPCTSTR lpszDeviceName,
    LPCTSTR lpszOutput,
    const void* lpInitData);

Parâmetros

lpszDriverName
Aponta para uma cadeia de caracteres terminada em nulo que especifica o nome do arquivo (sem extensão) do driver do dispositivo (por exemplo, "EPSON"). Você também pode passar um objeto CString para esse parâmetro.

lpszDeviceName
Aponta para uma cadeia de caracteres terminada em nulo que especifica o nome do dispositivo específico a ser compatível (por exemplo, "EPSON FX-80"). O parâmetro lpszDeviceName será usado se o módulo der suporte a mais de um dispositivo. Você também pode passar um objeto CString para esse parâmetro.

lpszOutput
Aponta para uma cadeia de caracteres terminada em nulo que especifica o nome do arquivo ou do dispositivo para o meio de saída físico (porta de saída ou arquivo). Você também pode passar um objeto CString para esse parâmetro.

lpInitData
Aponta para uma estrutura DEVMODE que contém dados de inicialização específicos do dispositivo para o driver do dispositivo. A função DocumentProperties do Windows recupera essa estrutura preenchida para um determinado dispositivo. O parâmetro lpInitData deve ser NULL se o driver do dispositivo deve usar a inicialização padrão (se houver) especificada pelo usuário por meio do Painel de Controle.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O arquivo de cabeçalho PRINT.H é necessário se a estrutura DEVMODE for usada.

Os nomes de dispositivo seguem estas convenções: dois-pontos finais (:) é recomendado, mas opcional. O Windows remove os dois-pontos de terminação para que um nome de dispositivo que termina com dois-pontos seja mapeado para a mesma porta que o mesmo nome sem dois pontos. Os nomes do driver e da porta não devem conter espaços à esquerda ou à direita. As funções de saída GDI não podem ser usadas com contextos de informações.

CDC::CreateIC

Cria um contexto de informações para o dispositivo especificado.

BOOL CreateIC(
    LPCTSTR lpszDriverName,
    LPCTSTR lpszDeviceName,
    LPCTSTR lpszOutput,
    const void* lpInitData);

Parâmetros

lpszDriverName
Aponta para uma cadeia de caracteres terminada em nulo que especifica o nome do arquivo (sem extensão) do driver do dispositivo (por exemplo, "EPSON"). Você pode passar um objeto CString para esse parâmetro.

lpszDeviceName
Aponta para uma cadeia de caracteres terminada em nulo que especifica o nome do dispositivo específico a ser compatível (por exemplo, "EPSON FX-80"). O parâmetro lpszDeviceName será usado se o módulo der suporte a mais de um dispositivo. Você pode passar um objeto CString para esse parâmetro.

lpszOutput
Aponta para uma cadeia de caracteres terminada em nulo que especifica o nome do arquivo ou do dispositivo para o meio de saída físico (porta ou arquivo). Você pode passar um objeto CString para esse parâmetro.

lpInitData
Aponta para dados de inicialização específicos do dispositivo para o driver do dispositivo. O parâmetro lpInitData deve ser NULL se o driver do dispositivo deve usar a inicialização padrão (se houver) especificada pelo usuário por meio do Painel de Controle. Consulte CreateDC para obter o formato de dados para inicialização específica do dispositivo.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

Esse contexto de informações fornece uma maneira rápida de obter informações sobre o dispositivo sem criar um contexto de dispositivo.

Os nomes de dispositivo seguem estas convenções: dois-pontos finais (:) é recomendado, mas opcional. O Windows remove os dois-pontos de terminação para que um nome de dispositivo que termina com dois-pontos seja mapeado para a mesma porta que o mesmo nome sem dois pontos. Os nomes do driver e da porta não devem conter espaços à esquerda ou à direita. As funções de saída GDI não podem ser usadas com contextos de informações.

CDC::DeleteDC

Em geral, não chame essa função; O destruidor fará isso por você.

BOOL DeleteDC();

Valor de Devolução

Diferente de zero se a função foi concluída com êxito; caso contrário, 0.

Comentários

A função de membro DeleteDC exclui os contextos do dispositivo Windows associados com m_hDC no objeto CDC atual. Se esse CDC objeto for o último contexto de dispositivo ativo para um determinado dispositivo, todos os recursos de armazenamento e do sistema usados pelo dispositivo serão liberados.

Um aplicativo não deve chamar DeleteDC se os objetos tiverem sido selecionados no contexto do dispositivo. Os objetos devem primeiro ser selecionados fora do contexto do dispositivo antes de serem excluídos.

Um aplicativo não deve excluir um contexto de dispositivo cujo identificador foi obtido chamando CWnd::GetDC. Em vez disso, ele deve chamar CWnd::ReleaseDC para liberar o contexto do dispositivo. A classes CClientDC e CWindowDC são fornecidas para encapsular essa funcionalidade.

A função DeleteDC geralmente é usada para excluir contextos de dispositivo criados com CreateDC, CreateIC ou CreateCompatibleDC.

Exemplo

Confira o exemplo de CPrintDialog::GetPrinterDC.

CDC::DeleteTempMap

Chamado automaticamente pelo manipulador CWinApp de tempo ocioso, exclui todos os objetos temporários CDC criados pelo FromHandle, DeleteTempMap mas não destrói os identificadores de contexto do dispositivo ( hDCs) temporariamente associados aos CDC objetos.

static void PASCAL DeleteTempMap();

CDC::Detach

Chame essa função para desanexar m_hDC (o contexto do dispositivo de saída) do objeto CDC e definir m_hDC e m_hAttribDC como NULL.

HDC Detach();

Valor de Devolução

O contexto de dispositivo Windows.

CDC::DPtoHIMETRIC

Use essa função quando você fornecer tamanhos HIMETRIC para OLE, convertendo pixels em HIMETRIC.

void DPtoHIMETRIC(LPSIZE lpSize) const;

Parâmetros

lpSize
Aponta para uma estrutura SIZE ou um objeto CSize.

Comentários

Se o modo de mapeamento do objeto de contexto do dispositivo forMM_LOENGLISH, MM_HIENGLISH, MM_LOMETRICou MM_HIMETRIC, a conversão será baseada no número de pixels na polegada física. Se o modo de mapeamento for um dos outros modos não restritos (por exemplo, MM_TEXT), a conversão será baseada no número de pixels na polegada lógica.

CDC::DPtoLP

Converte unidades de dispositivo em unidades lógicas.

void DPtoLP(
    LPPOINT lpPoints,
    int nCount = 1) const;

void DPtoLP(LPRECT lpRect) const;
void DPtoLP(LPSIZE lpSize) const;

Parâmetros

lpPoints
Aponta para uma matriz de estruturas POINT ou objetos CPoint.

nCount
O número de pontos na matriz.

lpRect
Aponta para uma estrutura RECT ou um objeto CRect. Esse parâmetro é usado para o caso simples de converter um retângulo de pontos de dispositivo em pontos lógicos.

lpSize
Aponta para uma estrutura SIZE ou um objeto CSize.

Comentários

A função mapeia as coordenadas de cada ponto, ou dimensão de um tamanho, do sistema de coordenadas do dispositivo para o sistema de coordenadas lógica do GDI. A conversão depende do modo de mapeamento atual e das configurações das origens e extensões da janela e do visor do dispositivo.

CDC::Draw3dRect

Chame essa função de membro para desenhar um retângulo tridimensional.

void Draw3dRect(
    LPCRECT lpRect,
    COLORREF clrTopLeft,
    COLORREF clrBottomRight);

void Draw3dRect(
    int x,
    int y,
    int cx,
    int cy,
    COLORREF clrTopLeft,
    COLORREF clrBottomRight);

Parâmetros

lpRect
Especifica o retângulo delimitador (em unidades lógicas). Você pode passar um ponteiro para uma estrutura RECT ou um objeto CRect para esse parâmetro.

clrTopLeft
Especifica a cor dos lados superior e esquerdo do retângulo tridimensional.

clrBottomRight
Especifica a cor dos lados inferior e direito do retângulo tridimensional.

x
Especifica a coordenada x lógica do canto superior esquerdo do retângulo tridimensional.

y
Especifica a coordenada y lógica do canto superior esquerdo do retângulo tridimensional.

cx
Especifica a largura do retângulo tridimensional.

cy
Especifica a altura do retângulo tridimensional.

Comentários

O retângulo será desenhado com os lados superior e esquerdo na cor especificada por clrTopLeft e os lados inferior e direito na cor especificada por clrBottomRight.

Exemplo

void CDCView::Draw3dRect(CDC *pDC)
{
   // get the client area
   CRect rect;
   GetClientRect(rect);

   // shrink our rect 20 pixels on all sides
   rect.DeflateRect(20, 20);

   // draw a rectangle with red top and left sides, and
   // green right and bottom sides.
   pDC->Draw3dRect(rect, RGB(255, 0, 0), RGB(0, 255, 0));

   // This call to the four-integer override would draw
   // the same rectangle with a little less convenience:

   // pDC->Draw3dRect(rect.left, rect.top, rect.Width(), rect.Height(),
   //    RGB(255, 0, 0), RGB(0, 255, 0));
}

CDC::DrawDragRect

Chame essa função de membro repetidamente para redesenhar um retângulo de arrastar.

void DrawDragRect(
    LPCRECT lpRect,
    SIZE size,
    LPCRECT lpRectLast,
    SIZE sizeLast,
    CBrush* pBrush = NULL,
    CBrush* pBrushLast = NULL);

Parâmetros

lpRect
Aponta para uma estrutura RECT ou um objeto CRect que especifica as coordenadas lógicas de um retângulo, nesse caso, a posição final do retângulo sendo redesenhado.

size
Especifica o deslocamento do canto superior esquerdo da borda externa para o canto superior esquerdo da borda interna (ou seja, a espessura da borda) de um retângulo.

lpRectLast
Aponta para uma estrutura RECT ou um objeto CRect que especifica as coordenadas lógicas da posição de um retângulo, nesse caso, a posição original do retângulo sendo redesenhado.

sizeLast
Especifica o deslocamento do canto superior esquerdo da borda externa para o canto superior esquerdo da borda interna (ou seja, a espessura da borda) do retângulo original sendo redesenhado.

pBrush
Ponteiro para um objeto de pincel. Defina como NULL para usar o pincel de meio tom padrão.

pBrushLast
Ponteiro para o último objeto de pincel usado. Defina como NULL para usar o pincel de meio tom padrão.

Comentários

Chame-o em um loop à medida que você amostra a posição do mouse, a fim de fornecer comentários visuais. Quando você chama DrawDragRect, o retângulo anterior é apagado e um novo é desenhado. Por exemplo, à medida que o usuário arrasta um retângulo pela tela, DrawDragRect apagará o retângulo original e redesenhará um novo em sua nova posição. Por padrão, DrawDragRect desenha o retângulo usando um pincel de meio tom para eliminar a cintilação e para criar a aparência de um retângulo suavemente móvel.

Na primeira vez que você chamar DrawDragRect, o parâmetro lpRectLast deve ser NULL.

CDC::DrawEdge

Chame essa função de membro para desenhar as bordas de um retângulo do tipo e estilo especificados.

BOOL DrawEdge(
    LPRECT lpRect,
    UINT nEdge,
    UINT nFlags);

Parâmetros

lpRect
Um ponteiro para uma estrutura RECT que contém as coordenadas lógicas do retângulo.

nEdge
Especifica o tipo de borda interna e externa a ser desenhada. Esse parâmetro deve ser uma combinação de um sinalizador de borda interna e um sinalizador de borda externa. Consulte DrawEdge no SDK do Windows para obter uma tabela dos tipos do parâmetro.

nFlags
Os sinalizadores que especificam o tipo de borda a ser desenhada. Consulte DrawEdge no SDK do Windows para obter uma tabela dos valores do parâmetro. Para linhas diagonais, os sinalizadores BF_RECT especificam o ponto final do vetor delimitado pelo parâmetro retângulo.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

CDC::DrawEscape

Acessa recursos de desenho de uma tela de vídeo que não estão disponíveis diretamente por meio da interface de dispositivo gráfico (GDI).

int DrawEscape(
    int nEscape,
    int nInputSize,
    LPCSTR lpszInputData);

Parâmetros

nEscape
Especifica a função de escape a ser executada.

nInputSize
Especifica o número de bytes de dados apontados pelo parâmetro lpszInputData.

lpszInputData
Aponta para a estrutura de entrada necessária para o escape especificado.

Valor de Devolução

Especifica o resultado da função . Maior que zero se bem-sucedido, exceto para o escape de sorteio, que verifica apenas a implementação, ou zero se o QUERYESCSUPPORT escape não for implementado, ou menor que zero se ocorreu um erro.

Comentários

Quando um aplicativo chama DrawEscape, os dados identificados por nInputSize e lpszInputData são passados diretamente para o driver de exibição especificado.

CDC::DrawFocusRect

Desenha um retângulo no estilo usado para indicar que o retângulo tem o foco.

void DrawFocusRect(LPCRECT lpRect);

Parâmetros

lpRect
Aponta para uma estrutura RECT ou um objeto CRect que especifica as coordenadas lógicas do retângulo a ser desenhado.

Comentários

Como essa é uma função XOR booliana (^), chamar essa função uma segunda vez com o mesmo retângulo remove o retângulo da exibição. O retângulo desenhado por essa função não pode ser percorrido. Para percorrer uma área que contém um retângulo desenhado por essa função, primeiro chame DrawFocusRect para remover o retângulo da exibição, depois role a área e, em seguida, chame DrawFocusRect novamente para desenhar o retângulo na nova posição.

Cuidado

DrawFocusRect funciona apenas no modo MM_TEXT. Em outros modos, essa função não desenha o retângulo de foco corretamente, mas não retorna valores de erro.

CDC::DrawFrameControl

Chame essa função de membro para desenhar um controle de quadro do tipo e estilo especificados.

BOOL DrawFrameControl(
    LPRECT lpRect,
    UINT nType,
    UINT nState);

Parâmetros

lpRect
Um ponteiro para uma estrutura RECT que contém as coordenadas lógicas do retângulo.

nType
Especifica o tipo de controle de quadro a ser desenhado. Consulte o parâmetro uType em DrawFrameControl no SDK do Windows para obter uma lista dos valores possíveis desse parâmetro.

nState
Especifica o estado inicial do controle de quadro. Pode ser um ou mais dos valores descritos para o parâmetro uState em DrawFrameControl no SDK do Windows. Use o nState valor DFCS_ADJUSTRECT para ajustar o retângulo delimitador para excluir a borda ao redor do botão de ação.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

Em vários casos, nState depende do parâmetro nType. A lista a seguir mostra a relação entre os quatro valores nType e nState:

  • DFC_BUTTON

    • DFCS_BUTTON3STATE Botão de três estados

    • DFCS_BUTTONCHECK Caixa de seleção

    • DFCS_BUTTONPUSH Botão de ação

    • DFCS_BUTTONRADIO Botão de opção

    • DFCS_BUTTONRADIOIMAGE Imagem para botão de opção (se não for quadrado precisa de imagem)

    • DFCS_BUTTONRADIOMASK Máscara para botão de opção (se não for quadrado precisa de máscara)

  • DFC_CAPTION

    • DFCS_CAPTIONCLOSE Botão fechar

    • DFCS_CAPTIONHELP Botão de ajuda

    • DFCS_CAPTIONMAX Botão maximizar

    • DFCS_CAPTIONMIN Botão minimizar

    • DFCS_CAPTIONRESTORE Botão restaurar

  • DFC_MENU

    • DFCS_MENUARROW Seta de submenu

    • DFCS_MENUBULLET Marcador

    • DFCS_MENUCHECK Marca de seleção

  • DFC_SCROLL

    • DFCS_SCROLLCOMBOBOX Barra de rolagem da caixa de combinação

    • DFCS_SCROLLDOWN Seta para baixo da barra de rolagem

    • DFCS_SCROLLLEFT Seta para a esquerda da barra de rolagem

    • DFCS_SCROLLRIGHT Seta para a direita da barra de rolagem

    • DFCS_SCROLLSIZEGRIP Alça de tamanho no canto inferior direito da janela

    • DFCS_SCROLLUP Seta para cima da barra de rolagem

Exemplo

Esse código desenha a alça de tamanho no canto inferior direito da janela. Ele é apropriado para o manipulador OnPaint de uma caixa de diálogo, que não tem estilos e normalmente não contém outros controles (como uma barra de status) que podem lhe dar uma alça de tamanho.

void CDCView::DrawFC(CDC *pDC)
{
   CRect rc;
   GetClientRect(&rc);

   rc.left = rc.right - ::GetSystemMetrics(SM_CXHSCROLL);
   rc.top = rc.bottom - ::GetSystemMetrics(SM_CYVSCROLL);

   pDC->DrawFrameControl(rc, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
}

CDC::DrawIcon

Desenha um ícone no dispositivo representado pelo objeto atual CDC.

BOOL DrawIcon(
    int x,
    int y,
    HICON hIcon);

BOOL DrawIcon(
    POINT point,
    HICON hIcon);

Parâmetros

x
Especifica a coordenada x lógica do canto superior esquerdo do ícone.

y
Especifica a coordenada y lógica do canto superior esquerdo do ícone.

hIcon
Identifica o identificador do ícone a ser desenhado.

point
Especifica as coordenada lógicas x e y do canto superior esquerdo do ícone. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Diferente de zero se a função foi concluída com êxito; caso contrário, 0.

Comentários

A função coloca o canto superior esquerdo do ícone no local especificado por x e y. O local está sujeito ao modo de mapeamento atual do contexto do dispositivo.

O recurso de ícone deve ter sido carregado anteriormente usando as funções CWinApp::LoadIcon, CWinApp::LoadStandardIcon ou CWinApp::LoadOEMIcon. O modo de mapeamento de MM_TEXT deve ser selecionado antes de usar essa função.

Exemplo

Confira o exemplo de CWnd::IsIconic.

CDC::DrawState

Chame essa função de membro para exibir uma imagem e aplicar um efeito visual para indicar um estado, como um estado desabilitado ou padrão.

Observação

Para todos os estados nFlag, exceto DSS_NORMAL, a imagem é convertida em monocromática antes que o efeito visual seja aplicado.

BOOL DrawState(
    CPoint pt,
    CSize size,
    HBITMAP hBitmap,
    UINT nFlags,
    HBRUSH hBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    CBitmap* pBitmap,
    UINT nFlags,
    CBrush* pBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    HICON hIcon,
    UINT nFlags,
    HBRUSH hBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    HICON hIcon,
    UINT nFlags,
    CBrush* pBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    LPCTSTR lpszText,
    UINT nFlags,
    BOOL bPrefixText = TRUE,
    int nTextLen = 0,
    HBRUSH hBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    LPCTSTR lpszText,
    UINT nFlags,
    BOOL bPrefixText = TRUE,
    int nTextLen = 0,
    CBrush* pBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    DRAWSTATEPROC lpDrawProc,
    LPARAM lData,
    UINT nFlags,
    HBRUSH hBrush = NULL);

BOOL DrawState(
    CPoint pt,
    CSize size,
    DRAWSTATEPROC lpDrawProc,
    LPARAM lData,
    UINT nFlags,
    CBrush* pBrush = NULL);

Parâmetros

pt
Especifica o local da imagem.

size
Especifica o tamanho da imagem.

hBitmap
Um identificador para um bitmap.

nFlags
Sinalizadores que especificam o tipo e o estado da imagem. Consulte DrawState no SDK do Windows para obter os possíveis tipos e estados nFlags.

hBrush
Um identificador para um pincel.

pBitmap
Um ponteiro para um objeto CBitmap.

pBrush
Um ponteiro para um objeto CBrush.

hIcon
Um identificador para um ícone.

lpszText
Um ponteiro para texto.

bPrefixText
Texto que pode conter um acelerador mnemônico. O parâmetro lData especifica o endereço da cadeia de caracteres e o parâmetro nTextLen especifica o comprimento. Se nTextLen for 0, a cadeia de caracteres será considerada terminada em nulo.

nTextLen
Comprimento da cadeia de caracteres de texto apontada por lpszText. Se nTextLen for 0, a cadeia de caracteres será considerada terminada em nulo.

lpDrawProc
Um ponteiro para uma função de retorno de chamada usada para renderizar uma imagem. Esse parâmetro será necessário se o tipo de imagem em nFlags for DST_COMPLEX. É opcional e pode ser NULL se o tipo de imagem for DST_TEXT. Para todos os outros tipos de imagem, esse parâmetro é ignorado. Para obter mais informações sobre a função de retorno de chamada, consulte a função DrawStateProc no SDK do Windows.

lData
Especifica informações sobre a imagem. O significado desse parâmetro depende do tipo de imagem.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

CDC::DrawText

Chame essa função de membro para formatar texto no retângulo fornecido. Para especificar mais opções de formatação, use CDC::DrawTextEx.

virtual int DrawText(
    LPCTSTR lpszString,
    int nCount,
    LPRECT lpRect,
    UINT nFormat);

int DrawText(
    const CString& str,
    LPRECT lpRect,
    UINT nFormat);

Parâmetros

lpszString
Aponta para a cadeia de caracteres a ser desenhada. Se nCount for -1, a cadeia de caracteres deve ser terminada em nulo.

nCount
Especifica o número de caracteres na cadeia de caracteres. Se nCount for -1, presume-se que lpszString seja um ponteiro longo para uma cadeia de caracteres terminada em nulo e DrawText calculará a contagem de caracteres automaticamente.

lpRect
Aponta para uma estrutura RECT ou objeto CRect que contém o retângulo (em coordenadas lógicas) no qual o texto deve ser formatado.

str
Um objeto CString que contém os caracteres especificados a serem desenhados.

nFormat
Especifica o método de formatação do texto. Pode ser qualquer combinação de valores descritos para o parâmetro uFormat em DrawText no SDK do Windows. (combine usando o operador OR bit a bit):

Observação

Algumas combinações de sinalizador uFormat podem fazer com que a cadeia de caracteres passada seja modificada. Usar DT_MODIFYSTRING com DT_END_ELLIPSIS ou DT_PATH_ELLIPSIS pode fazer com que a cadeia de caracteres seja modificada, causando uma asserção na substituição de CString. Os valores DT_CALCRECT, DT_EXTERNALLEADING, DT_INTERNAL, DT_NOCLIP e DT_NOPREFIX não podem ser usados com o valor DT_TABSTOP.

Valor de Devolução

A altura do texto se a função for bem-sucedida.

Comentários

Ele formata o texto expandindo as guias em espaços apropriados, alinhando o texto à esquerda, à direita ou ao centro do retângulo especificado e dividindo o texto em linhas que se ajustam ao retângulo especificado. O tipo de formatação é especificado por nFormat.

Essa função membro usa a fonte, a cor do texto e a cor da tela de fundo selecionadas do contexto do dispositivo para desenhar o texto. A menos que o formato seja usado, DrawText recorta o texto para que o DT_NOCLIP texto não apareça fora do retângulo fornecido. Supõe-se que toda a formatação tenha várias linhas, a menos que o formato DT_SINGLELINE seja dado.

Se a fonte selecionada for muito grande para o retângulo especificado, a DrawText função de membro não tentará substituir uma fonte menor.

Se o sinalizador DT_CALCRECT for especificado, o retângulo especificado por lpRect será atualizado para refletir a largura e a altura necessárias para desenhar o texto.

Se o sinalizador de alinhamento de texto TA_UPDATECP tiver sido definido (consulte CDC::SetTextAlign), DrawText exibirá o texto começando na posição atual, em vez de à esquerda do retângulo especificado. DrawText não quebrará o texto quando o sinalizador tiver sido definido (ou seja, o TA_UPDATECPDT_WORDBREAK sinalizador não terá efeito).

A cor do texto pode ser definida por CDC::SetTextColor.

CDC::DrawTextEx

Formata o texto no retângulo especificado.

virtual int DrawTextEx(
    LPTSTR lpszString,
    int nCount,
    LPRECT lpRect,
    UINT nFormat,
    LPDRAWTEXTPARAMS lpDTParams);

int DrawTextEx(
    const CString& str,
    LPRECT lpRect,
    UINT nFormat,
    LPDRAWTEXTPARAMS lpDTParams);

Parâmetros

lpszString
Aponta para a cadeia de caracteres a ser desenhada. Se nCount for -1, a cadeia de caracteres deve ser terminada em nulo.

nCount
Especifica o número de caracteres na cadeia de caracteres. Se nCount for -1, presume-se que lpszString seja um ponteiro longo para uma cadeia de caracteres terminada em nulo e DrawText calculará a contagem de caracteres automaticamente.

lpRect
Aponta para uma estrutura RECT ou objeto CRect que contém o retângulo (em coordenadas lógicas) no qual o texto deve ser formatado.

str
Um objeto CString que contém os caracteres especificados a serem desenhados.

nFormat
Especifica o método de formatação do texto. Pode ser qualquer combinação de valores descritos para o parâmetro uFormat em DrawText no SDK do Windows. (combine usando o operador OR bit a bit):

Observação

Algumas combinações de sinalizador uFormat podem fazer com que a cadeia de caracteres passada seja modificada. Usar DT_MODIFYSTRING com DT_END_ELLIPSIS ou DT_PATH_ELLIPSIS pode fazer com que a cadeia de caracteres seja modificada, causando uma asserção na substituição de CString. Os valores DT_CALCRECT, DT_EXTERNALLEADING, DT_INTERNAL, DT_NOCLIP e DT_NOPREFIX não podem ser usados com o valor DT_TABSTOP.

lpDTParams
Ponteiro para uma DRAWTEXTPARAMS estrutura que especifica mais opções de formatação. Esse parâmetro pode ser NULL.

Comentários

Ele formata o texto expandindo as guias em espaços apropriados, alinhando o texto à esquerda, à direita ou ao centro do retângulo especificado e dividindo o texto em linhas que se ajustam ao retângulo especificado. O tipo de formatação é especificado por nFormat e lpDTParams. Para saber mais, confira CDC::DrawText e DrawTextEx no SDK do Windows.

A cor do texto pode ser definida por CDC::SetTextColor.

CDC::Ellipse

Desenha uma elipse.

BOOL Ellipse(
    int x1,
    int y1,
    int x2,
    int y2);

BOOL Ellipse(LPCRECT lpRect);

Parâmetros

x1
Especifica a coordenada x lógica do canto superior esquerdo do retângulo delimitador da elipse.

y1
Especifica a coordenada y lógica do canto superior esquerdo do retângulo delimitador da elipse.

x2
Especifica a coordenada x lógica do canto inferior direito do retângulo delimitador da elipse.

y2
Especifica a coordenada y lógica do canto inferior direito do retângulo delimitador da elipse.

lpRect
Especifica o retângulo delimitador da elipse. Você também pode passar um objeto CRect para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O centro da elipse é o centro do retângulo delimitador especificado porx1, y1 e x2, ou y2 e lpRect. A elipse é desenhada com a caneta atual e seu interior é preenchido com o pincel atual.

A figura desenhada por essa função se estende até, mas não inclui, as coordenadas direita e inferior. Isso significa que a altura da figura é y2 - y1 e a largura da figura é x2 - x1.

Se a largura ou a altura do retângulo delimitador for 0, nenhuma elipse será desenhada.

CDC::EndDoc

Encerra um trabalho de impressão iniciado por uma chamada da função de membro StartDoc.

int EndDoc();

Valor de Devolução

Maior ou igual a 0 se a função tiver êxito, ou um valor negativo se tiver ocorrido um erro.

Comentários

Essa função de membro substitui o escape da impressora ENDDOC e deve ser chamada imediatamente após concluir um trabalho de impressão bem-sucedido.

Se um aplicativo encontrar um erro de impressão ou uma operação de impressão cancelada, ele não deverá tentar encerrar a operação usando EndDoc ou AbortDoc. A GDI encerra automaticamente a operação antes de retornar o valor de erro.

Essa função não deve ser usada dentro de metaarquivos.

Exemplo

Confira o exemplo de CDC::StartDoc.

CDC::EndPage

Informa ao dispositivo que o aplicativo terminou de gravar em uma página.

int EndPage();

Valor de Devolução

Maior ou igual a 0 se a função tiver êxito, ou um valor negativo se tiver ocorrido um erro.

Comentários

Essa função de membro normalmente é usada para direcionar o driver de dispositivo para avançar para uma nova página.

Essa função membro substitui o escape da impressora NEWFRAME. Diferentemente de NEWFRAME, essa função é sempre chamada depois de imprimir uma página.

Exemplo

Confira o exemplo de CDC::StartDoc.

CDC::EndPath

Fecha um colchete de caminho e seleciona o caminho definido pelo colchete no contexto do dispositivo.

BOOL EndPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Exemplo

Confira o exemplo de CDC::BeginPath.

CDC::EnumObjects

Enumera as canetas e pincéis disponíveis em um contexto de dispositivo.

int EnumObjects(
    int nObjectType,
    int (CALLBACK* lpfn)(
    LPVOID,
    LPARAM),
    LPARAM lpData);

Parâmetros

nObjectType
Especifica o tipo de objeto. Ele pode ter os valores OBJ_BRUSH ou OBJ_PEN.

lpfn
É o endereço de instância de procedimento da função de retorno de chamada fornecida pelo aplicativo. Consulte a seção “Comentários” abaixo.

lpData
Aponta para os dados fornecidos pelo aplicativo. Os dados são passados para a função de retorno de chamada junto com as informações do objeto.

Valor de Devolução

Especifica o último valor retornado pela função de retorno de chamada. Seu significado é definido pelo usuário.

Comentários

Para cada objeto de um determinado tipo, a função de retorno de chamada que você passa é chamada com as informações desse objeto. O sistema chama a função de retorno de chamada até que não haja mais objetos ou a função de retorno de chamada retorne 0.

Novos recursos do Microsoft Visual C++ permitem que você use uma função comum como a função passada para EnumObjects. O endereço passado para EnumObjects é um ponteiro para uma função exportada com EXPORT e com a convenção de chamada Pascal. Em aplicativos de modo de proteção, você não precisa criar essa função com a função do Windows ou liberar a função após o uso com a FreeProcInstance função do WindowsMakeProcInstance.

Você também não precisa exportar o nome da função em uma EXPORTS instrução no arquivo de definição de módulo do aplicativo. Em vez disso, você pode usar o modificador de função EXPORT, como em

int CALLBACK EXPORT AFunction (LPSTR, LPSTR);

para fazer com que o compilador emita o registro de exportação adequado para exportação por nome sem aliasing. Isso funciona para a maioria das necessidades. Para alguns casos especiais, como exportar uma função por ordinal ou aliasing da exportação, você ainda precisa usar uma instrução EXPORTS em um arquivo de definição de módulo.

Para compilar programas do Microsoft Foundation, você normalmente usará as /GA opções e /GEs compilador. A /Gw opção de compilador não é usada com as classes do Microsoft Foundation. (Se você usar a função do Windows, precisará converter explicitamente o ponteiro de FARPROC função MakeProcInstanceretornado para o tipo necessário nesta API.) As interfaces de registro de retorno de chamada agora são seguras para o tipo (você deve passar um ponteiro de função que aponte para o tipo certo de função para o retorno de chamada específico).

Além disso, todas as funções de retorno de chamada devem interceptar exceções do Microsoft Foundation antes de retornar ao Windows, já que as exceções não podem ser lançadas além dos limites de retorno de chamada. Para mais informações sobre exceções, confira o artigo Exceções.

Exemplo

// print some info about a pen we're ready to enumerate
BOOL CALLBACK EnumObjectHandler(LPVOID lpLogObject, LPARAM /* lpData */)
{
   LOGPEN *pPen = (LOGPEN *)lpLogObject;

   switch (pPen->lopnStyle)
   {
   case PS_SOLID:
      TRACE0("PS_SOLID:      ");
      break;
   case PS_DASH:
      TRACE0("PS_DASH:       ");
      break;
   case PS_DOT:
      TRACE0("PS_DOT:        ");
      break;
   case PS_DASHDOT:
      TRACE0("PS_DASHDOT:    ");
      break;
   case PS_DASHDOTDOT:
      TRACE0("PS_DASHDOTDOT: ");
      break;
   case PS_NULL:
      TRACE0("PS_NULL:       ");
      break;
   case PS_INSIDEFRAME:
      TRACE0("PS_INSIDEFRAME:");
      break;
   default:
      TRACE0("unk style:");
   }

   TRACE2("Color: 0x%8.8X, Width: %d\n", pPen->lopnColor, pPen->lopnWidth);
   return TRUE;
}

// get the default printer and enumerate the pens it has
void CDCView::OnEnumPens()
{
   CPrintDialog dlg(FALSE);
   dlg.GetDefaults();
   HDC hdc = dlg.GetPrinterDC();

   if (hdc != NULL)
   {
      CDC dc;
      dc.Attach(hdc);
      VERIFY(dc.EnumObjects(OBJ_PEN, EnumObjectHandler, 0));
   }
}

CDC::Escape

Essa função de membro é praticamente obsoleta para a programação do Win32.

virtual int Escape(
    int nEscape,
    int nCount,
    LPCSTR lpszInData,
    LPVOID lpOutData);

int Escape(
    int nEscape,
    int nInputSize,
    LPCSTR lpszInputData,
    int nOutputSize,
    LPSTR lpszOutputData);

Parâmetros

nEscape
Especifica a função de escape a ser executada.

Para obter uma lista completa de funções de escape, consulte Escape no SDK do Windows.

nCount
Especifica o número de bytes de dados apontados por lpszInData.

lpszInData
Aponta para a estrutura de dados de entrada necessária para esse escape.

lpOutData
Aponta para a estrutura que deve receber a saída desse escape. O parâmetro lpOutData será NULL se nenhum dado for retornado.

nInputSize
Especifica o número de bytes de dados apontados pelo parâmetro lpszInputData.

lpszInputData
Aponta para a estrutura de entrada necessária para o escape especificado.

nOutputSize
Especifica o número de bytes de dados apontados pelo parâmetro lpszOutputData.

lpszOutputData
Aponta para a estrutura que recebe a saída desse escape. Esse parâmetro deve ser NULL se nenhum dado for retornado.

Valor de Devolução

Um valor positivo será retornado se a função for bem-sucedida, exceto pelo escape QUERYESCSUPPORT, que verifica apenas a implementação. Zero é retornado se o escape não for implementado. Um valor negativo será retornado se ocorrer um erro. Veja a seguir valores de erro comuns:

  • SP_ERROR Erro geral.

  • SP_OUTOFDISK No momento, não há espaço em disco suficiente disponível para spooling e não haverá mais espaço disponível.

  • SP_OUTOFMEMORY Não há memória suficiente disponível para spooling.

  • SP_USERABORT O usuário finalizou o trabalho por meio do Gerenciador de impressão.

Comentários

Dos escapes de impressora originais, somente QUERYESCSUPPORT tem suporte em aplicativos Win32. Todos os outros escapes de impressora são obsoletos e têm suporte apenas para compatibilidade com aplicativos de 16 bits.

Para a programação do Win32, CDC agora fornece seis funções de membro que substituem suas escapes de impressora correspondentes:

Além disso, CDC::GetDeviceCaps dá suporte a índices Win32 que substituem outros escapes de impressora. Confira GetDeviceCaps no SDK do Windows para mais informações.

Essa função de membro permite que os aplicativos acessem recursos de um dispositivo específico que não estão disponíveis diretamente por meio do GDI.

Use a primeira versão se o aplicativo usar valores de escape predefinidos. Use a segunda versão se o aplicativo definir valores de escape privados. Confira ExtEscape no SDK do Windows para obter mais informações sobre a segunda versão.

CDC::ExcludeClipRect

Cria uma nova área de recorte que consiste na área de recorte existente menos o retângulo especificado.

int ExcludeClipRect(
    int x1,
    int y1,
    int x2,
    int y2);

int ExcludeClipRect(LPCRECT lpRect);

Parâmetros

x1
Especifica a coordenada x lógica do canto superior esquerdo do retângulo.

y1
Especifica a coordenada y lógica do canto superior esquerdo do retângulo.

x2
Especifica a coordenada x lógica do canto inferior direito do retângulo.

y2
Especifica a coordenada y lógica do canto inferior direito do retângulo.

lpRect
Especifica o retângulo. Também pode ser um objeto CRect.

Valor de Devolução

Especifica o tipo da nova área de recorte. Pode ser qualquer um dos seguintes valores:

  • COMPLEXREGION A região tem bordas sobrepostas.

  • ERROR Nenhuma região foi criada.

  • NULLREGION A região está vazia.

  • SIMPLEREGION A região não tem bordas sobrepostas.

Comentários

A largura do retângulo, especificado pelo valor absoluto de x2 - x1, não deve exceder 32.767 unidades. Esse limite também se aplica à altura do retângulo.

CDC::ExcludeUpdateRgn

Impede o desenho dentro de áreas inválidas de uma janela excluindo uma região atualizada na janela de uma área de recorte associada ao objeto CDC.

int ExcludeUpdateRgn(CWnd* pWnd);

Parâmetros

pWnd
Aponta para o objeto de janela cuja janela está sendo atualizada.

Valor de Devolução

O tipo de região excluída. Pode ser qualquer um dos seguintes valores:

  • COMPLEXREGION A região tem bordas sobrepostas.

  • ERROR Nenhuma região foi criada.

  • NULLREGION A região está vazia.

  • SIMPLEREGION A região não tem bordas sobrepostas.

CDC::ExtFloodFill

Preenche uma área da superfície de exibição com o pincel atual.

BOOL ExtFloodFill(
    int x,
    int y,
    COLORREF crColor,
    UINT nFillType);

Parâmetros

x
Especifica a coordenada x lógica do ponto em que o preenchimento começa.

y
Especifica a coordenada y lógica do ponto em que o preenchimento começa.

crColor
Especifica a cor do limite ou da área a ser preenchida. A interpretação de crColor depende do valor de nFillType.

nFillType
Especifica o tipo de preenchimento de inundação a ser executado. Deve ser um dos seguintes valores:

  • FLOODFILLBORDER A área de preenchimento é limitada pela cor especificada por crColor. Esse estilo é idêntico ao preenchimento executado por FloodFill.

  • FLOODFILLSURFACE A área de preenchimento é definida pela cor especificada por crColor. O preenchimento continua para fora em todas as direções, desde que a cor seja encontrada. Esse estilo é útil para preencher áreas com limites com várias cores.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0 se o preenchimento não puder ser concluído, se o ponto determinado tiver a cor limite especificada por (se foi solicitado), se o ponto dado não tiver a cor especificada por crColorcrColor (se foi solicitado) ou se FLOODFILLBORDERFLOODFILLSURFACE o ponto estiver fora da região de recorte.

Comentários

Essa função membro oferece mais flexibilidade do que FloodFill porque você pode especificar um tipo de preenchimento em nFillType.

Se nFillType estiver definido como FLOODFILLBORDER, a área será assumida como completamente limitada pela cor especificada por crColor. A função começa no ponto especificado por x e y, e preenche todas as direções até o limite de cor.

Se nFillType estiver definido como FLOODFILLSURFACE, a função começará no ponto especificado por x e y, e continuará em todas as direções, preenchendo todas as áreas adjacentes que contêm a cor especificada por crColor.

Somente os contextos e dispositivos de dispositivo de memória que dão suporte à tecnologia de exibição de varredura ExtFloodFill. Para obter mais informações, confira a função do membro GetDeviceCaps.

CDC::ExtTextOut

Chame essa função de membro para gravar uma cadeia de caracteres dentro de uma região retangular usando a fonte selecionada no momento.

virtual BOOL ExtTextOut(
    int x,
    int y,
    UINT nOptions,
    LPCRECT lpRect,
    LPCTSTR lpszString,
    UINT nCount,
    LPINT lpDxWidths);

BOOL ExtTextOut(
    int x,
    int y,
    UINT nOptions,
    LPCRECT lpRect,
    const CString& str,
    LPINT lpDxWidths);

Parâmetros

x
Especifica a coordenada x lógica da célula de caracteres para o primeiro caractere na cadeia de caracteres especificada.

y
Especifica a coordenada y lógica da parte superior da célula de caracteres para o primeiro caractere na cadeia de caracteres especificada.

nOptions
Especifica o tipo de retângulo. Esse parâmetro pode ser um, ambos ou nenhum dos valores a seguir:

  • ETO_CLIPPED Especifica que o texto é recortado no retângulo.

  • ETO_OPAQUE Especifica que a cor da tela de fundo atual preenche o retângulo. (Você pode definir e consultar a cor da tela de fundo atual com as funções de membro SetBkColor e GetBkColor.)

lpRect
Aponta para uma estrutura RECT que determina as dimensões do retângulo. Esse parâmetro pode ser NULL. Você também pode passar um objeto CRect para esse parâmetro.

lpszString
Aponta para a cadeia de caracteres especificada a ser desenhada. Você também pode passar um objeto CString para esse parâmetro.

nCount
Especifica o número de caracteres na cadeia de caracteres.

lpDxWidths
Aponta para uma matriz de valores que indicam a distância entre as origens das células de caracteres adjacentes. Por exemplo, lpDxWidths[ i] as unidades lógicas separarão as origens da célula de caracteres i e da célula de caracteres i + 1. Se lpDxWidths for NULL, ExtTextOut usa o espaçamento padrão entre caracteres.

str
Um objeto CString que contém os caracteres especificados a serem desenhados.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

A área retangular pode ser opaca (preenchida com a cor da tela de fundo atual) e pode ser uma área de recorte.

Se nOptions for 0 e lpRect for NULL, a função gravará texto no contexto do dispositivo sem usar uma região retangular. Por padrão, a posição atual não é usada ou atualizada pela função. Se um aplicativo precisar atualizar a posição atual quando chamar ExtTextOut, o aplicativo poderá chamar SetTextAlign da função de membro CDC com nFlags definido como TA_UPDATECP. Quando esse sinalizador é definido, o Windows ignora x e y em chamadas subsequentes para ExtTextOut e usa a posição atual no lugar. Quando um aplicativo usa TA_UPDATECP para atualizar a posição atual, ExtTextOut define a posição atual para o final da linha de texto anterior ou para a posição especificada pelo último elemento da matriz apontado por lpDxWidths, o que for maior.

CDC::FillPath

Fecha as figuras abertas no caminho atual e preenche o interior do caminho usando o pincel atual e o modo de preenchimento de polígono.

BOOL FillPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Depois que seu interior é preenchido, o caminho é descartado do contexto do dispositivo.

CDC::FillRect

Chame essa função de membro para preencher um determinado retângulo usando o pincel especificado.

void FillRect(
    LPCRECT lpRect,
    CBrush* pBrush);

Parâmetros

lpRect
Aponta para uma estrutura RECT que contém as coordenadas lógicas do retângulo a ser preenchido. Você também pode passar um objeto CRect para esse parâmetro.

pBrush
Identifica o pincel usado para preencher o retângulo.

Comentários

A função preenche o retângulo completo, incluindo as bordas esquerda e superior, mas não preenche as bordas direita e inferior.

O pincel precisa ser criado usando funções de membro de membro CreateHatchBrush, CreatePatternBrush e CreateSolidBrushCBrush recuperado pela função do Windows GetStockObject.

Ao preencher o retângulo especificado, FillRect não inclua os lados direito e inferior do retângulo. O GDI preenche um retângulo até, mas não inclui, a coluna direita e a linha inferior, independentemente do modo de mapeamento atual. FillRect compara os valores dos membro top, bottom,left e right do retângulo especificado. Se bottom for menor ou igual a , ou se right for menor ou igual a topleft, o retângulo não será desenhado.

FillRect é semelhante a CDC::FillSolidRect; no entanto, FillRect usa um pincel e, portanto, pode ser usado para preencher um retângulo com uma cor sólida, uma cor pontilhada, pincéis eclodidos ou um padrão. FillSolidRect usa apenas cores sólidas (indicadas por um parâmetro COLORREF). FillRect geralmente é mais lento do que FillSolidRect.

CDC::FillRgn

Preenche a região especificada por pRgn com o pincel especificado por pBrush.

BOOL FillRgn(
    CRgn* pRgn,
    CBrush* pBrush);

Parâmetros

pRgn
Um ponteiro para a região a ser preenchida. As coordenadas para a região determinada são especificadas em unidades lógicas.

pBrush
Identifica o pincel a ser usado para preencher a região.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O pincel deve ser criado usando as funções de membro CreateHatchBrush, CreatePatternBrush, CreateSolidBrush de CBrush, ou ser recuperado por GetStockObject.

Exemplo

Confira o exemplo de CRgn::CreateRoundRectRgn.

CDC::FillSolidRect

Chame essa função de membro para preencher o retângulo fornecido com a cor sólida especificada.

void FillSolidRect(
    LPCRECT lpRect,
    COLORREF clr);

void FillSolidRect(
    int x,
    int y,
    int cx,
    int cy,
    COLORREF clr);

Parâmetros

lpRect
Especifica o retângulo delimitador (em unidades lógicas). Você pode passar um ponteiro para uma estrutura de dados RECT ou um objeto CRect para esse parâmetro.

clr Especifica a cor a ser usada para preencher o retângulo.

x
Especifica a coordenada x lógica do canto superior esquerdo do retângulo.

y
Especifica a coordenada y lógica do canto superior esquerdo do retângulo de destino.

cx
Especifica a largura do retângulo.

cy
Especifica a altura do retângulo.

Comentários

FillSolidRect é muito semelhante a CDC::FillRect; no entanto, FillSolidRect usa apenas cores sólidas (indicadas pelo parâmetro COLORREF), enquanto FillRect usa um pincel e, portanto, pode ser usado para preencher um retângulo com uma cor sólida, uma cor pontilhada, pincéis eclodidos ou um padrão. FillSolidRect geralmente é mais rápido do que FillRect.

Observação

Quando você chama FillSolidRect, a cor da tela de fundo, que foi definida anteriormente usando SetBkColor, é definida como a cor indicada por clr.

CDC::FlattenPath

Transforma as curvas no caminho selecionado no contexto atual do dispositivo e transforma cada curva em uma sequência de linhas.

BOOL FlattenPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

CDC::FloodFill

Preenche uma área da superfície de exibição com o pincel atual.

BOOL FloodFill(
    int x,
    int y,
    COLORREF crColor);

Parâmetros

x
Especifica a coordenada x lógica do ponto em que o preenchimento começa.

y
Especifica a coordenada y lógica do ponto em que o preenchimento começa.

crColor
Especifica a cor do limite.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0 será retornado se o preenchimento não puder ser concluído, o ponto fornecido tiver a cor limite especificada por crColor, ou o ponto estiver fora da região de recorte.

Comentários

A área é considerada limitada conforme especificado por crColor. A função FloodFill começa no ponto especificado por x e y, e continua em todas as direções até o limite de cor.

Somente os contextos e dispositivos de dispositivo de memória que suportam a tecnologia de exibição de varredura dão suporte à função de membro FloodFill. Para obter informações sobre a funcionalidade RC_BITBLT, consulte a função de membro GetDeviceCaps.

A função ExtFloodFill oferece funcionalidade semelhante, mas maior flexibilidade.

CDC::FrameRect

Desenha uma borda ao redor do retângulo especificado por lpRect.

void FrameRect(
    LPCRECT lpRect,
    CBrush* pBrush);

Parâmetros

lpRect
Aponta para uma estrutura RECT ou para um objeto CRect que contém as coordenadas lógicas dos cantos superior esquerdo e inferior direito do retângulo. Você também pode passar um objeto CRect para esse parâmetro.

pBrush
Identifica o pincel a ser usado para enquadrar o retângulo.

Comentários

A função usa o pincel determinado para desenhar a borda. A largura e a altura da borda são sempre 1 unidade lógica.

Se a coordenada do bottom retângulo for menor ou igual a , ou se right for menor ou igual a topleft, o retângulo não será desenhado.

A borda desenhada por FrameRect ela está na mesma posição que uma borda desenhada pela função de membro Rectangle usando as mesmas coordenadas (se Rectangle usar uma caneta de 1 unidade lógica de largura). O interior do retângulo não é preenchido por FrameRect.

CDC::FrameRgn

Desenha uma borda ao redor da região especificada por pRgn usando o pincel especificado por pBrush.

BOOL FrameRgn(
    CRgn* pRgn,
    CBrush* pBrush,
    int nWidth,
    int nHeight);

Parâmetros

pRgn
Aponta para o objeto CRgn que identifica a região a ser fechada em uma borda. As coordenadas para a região determinada são especificadas em unidades lógicas.

pBrush
Aponta para o objeto CBrush que identifica o pincel a ser usado para desenhar a borda.

nWidth
Especifica a largura da borda em traços de pincel verticais em unidades de dispositivo.

nHeight
Especifica a altura da borda em traços em pinceladas horizontais em unidades do dispositivo.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Exemplo

Confira o exemplo de CRgn::CombineRgn.

CDC::FromHandle

Retorna um ponteiro para um objeto CDC quando dado um identificador para um contexto de dispositivo.

static CDC* PASCAL FromHandle(HDC hDC);

Parâmetros

hDC
Contém um identificador de um contexto de dispositivo Windows.

Valor de Devolução

O ponteiro pode ser temporário e não deve ser armazenado além do uso imediato.

Comentários

Se um objeto CDC não estiver anexado ao identificador, um objeto temporário CDC será criado e anexado.

Exemplo

Confira o exemplo de CPrintDialog::GetPrinterDC.

CDC::GetArcDirection

Retorna a direção do arco atual para o contexto do dispositivo.

int GetArcDirection() const;

Valor de Devolução

Especifica a direção do arco atual, se bem-sucedido. A seguir estão os valores de retorno válidos:

  • AD_COUNTERCLOCKWISE Arcos e retângulos desenhados no sentido anti-horário.

  • AD_CLOCKWISE Arcs e retângulos desenhados no sentido horário.

Se ocorrer um erro, o valor retornado será zero.

Comentários

As funções de arco e retângulo usam a direção do arco.

CDC::GetAspectRatioFilter

Recupera a configuração do filtro de taxa de proporção atual.

CSize GetAspectRatioFilter() const;

Valor de Devolução

Um objeto CSize que representa a taxa de proporção usada pelo filtro de taxa de proporção atual.

Comentários

A proporção é a proporção formada pela largura e altura do pixel de um dispositivo. Informações sobre a proporção de um dispositivo são usadas na criação, seleção e exibição de fontes. O Windows fornece um filtro especial, o filtro de proporção de aspectos, para selecionar fontes projetadas para uma taxa de proporção específica de todas as fontes disponíveis. O filtro usa a taxa de proporção especificada pela função de membro SetMapperFlags.

CDC::GetBkColor

Retorna a cor do segundo plano atual.

COLORREF GetBkColor() const;

Valor de Devolução

Um valor para a cor RGB.

Comentários

Se o modo de fundo for OPAQUE, o sistema usará a cor da tela de fundo para preencher as lacunas em linhas estilizadas, as lacunas entre linhas eclodidas em pincéis e a tela de fundo em células de caracteres. O sistema também usa a cor da tela de fundo ao converter bitmaps entre contextos de dispositivo monocromático e de cor.

CDC::GetBkMode

Retorna o modo em segundo plano.

int GetBkMode() const;

Valor de Devolução

O modo em segundo plano atual, que pode ser OPAQUE ou TRANSPARENT.

Comentários

O modo de plano de fundo define se o sistema remove as cores de plano de fundo existentes na superfície de desenho antes de desenhar texto, pincéis com hachura ou qualquer estilo de caneta que não seja uma linha sólida.

CDC::GetBoundsRect

Retorna o retângulo delimitador acumulado atual para o contexto do dispositivo especificado.

UINT GetBoundsRect(
    LPRECT lpRectBounds,
    UINT flags);

Parâmetros

lpRectBounds
Aponta para um buffer que receberá o retângulo delimitador atual. O retângulo é retornado em coordenadas lógicas.

flags
Especifica se o retângulo delimitador deve ser limpo depois de retornado. Esse parâmetro deve ser zero ou definido como o seguinte valor:

  • DCB_RESET Força o retângulo delimitador a ser limpo depois de retornado.

Valor de Devolução

Especifica o estado atual do retângulo delimitador se a função for bem-sucedida. Pode ser uma combinação dos seguintes valores:

  • DCB_ACCUMULATE O acúmulo de retângulo delimitador está ocorrendo.

  • DCB_RESET O retângulo delimitador está vazio.

  • DCB_SET O retângulo delimitador não está vazio.

  • DCB_ENABLE O acúmulo de delimitação está ativado.

  • DCB_DISABLE O acúmulo de delimitação está desativado.

CDC::GetBrushOrg

Recupera a origem (em unidades de dispositivo) do pincel atualmente selecionado para o contexto do dispositivo.

CPoint GetBrushOrg() const;

Valor de Devolução

A origem atual do pincel (em unidades de dispositivo) como um objeto CPoint.

Comentários

A origem inicial do pincel está em (0,0) da área do cliente. O valor retornado especifica esse ponto em unidades de dispositivo em relação à origem da janela da área de trabalho.

CDC::GetCharacterPlacement

Recupera vários tipos de informações em uma cadeia de caracteres.

DWORD GetCharacterPlacement(
    LPCTSTR lpString,
    int nCount,
    int nMaxExtent,
    LPGCP_RESULTS lpResults,
    DWORD dwFlags) const;

DWORD GetCharacterPlacement(
    CString& str,
    int nMaxExtent,
    LPGCP_RESULTS lpResults,
    DWORD dwFlags) const;

Parâmetros

lpString
Um ponteiro para a cadeia de caracteres a ser processada.

nCount
Especifica o tamanho da cadeia de caracteres. Para a versão ANSI, é uma contagem e para a função Unicode é uma BYTEWORD contagem. Para obter mais informações, consulte GetCharacterPlacement.

nMaxExtent
Especifica a extensão máxima (em unidades lógicas) para a qual a cadeia de caracteres é processada. São ignorados os caracteres que, se processados, excederiam essa extensão. As computações para qualquer ordenação necessária ou matrizes de glifo se aplicam somente aos caracteres incluídos. Esse parâmetro será usado somente se o valor GCP_MAXEXTENT for especificado no parâmetro dwFlags. À medida que a função processa a cadeia de caracteres de entrada, cada caractere e sua extensão são adicionados à saída, extensão e outras matrizes somente se a extensão total ainda não tiver excedido o máximo. Depois que o limite for atingido, o processamento será interrompido.

lpResults
Ponteiro para uma estrutura GCP_Results que recebe os resultados da função.

dwFlags
Especifica como processar a cadeia de caracteres nas matrizes necessárias. Esse parâmetro pode ser um ou mais dos valores listados na seção dwFlags do tópico GetCharacterPlacement.

str
Um ponteiro para um objeto CString a ser processado.

Valor de Devolução

Se a função for bem-sucedida, o valor retornado será a largura e a altura da cadeia de caracteres em unidades lógicas.

Se a função falhar, o valor retornado será zero.

Comentários

Essa função membro emula a funcionalidade da função GetCharacterPlacement, conforme descrito no SDK do Windows.

CDC::GetCharABCWidths

Recupera as larguras de caracteres consecutivos em um intervalo especificado da fonte TrueType atual.

BOOL GetCharABCWidths(
    UINT nFirstChar,
    UINT nLastChar,
    LPABC lpabc) const;

BOOL GetCharABCWidths(
    UINT nFirstChar,
    UINT nLastChar,
    LPABCFLOAT lpABCF) const;

Parâmetros

nFirstChar
Especifica o primeiro caractere no intervalo de caracteres da fonte atual para a qual as larguras de caractere são retornadas.

nLastChar
Especifica o último caractere no intervalo de caracteres da fonte atual para a qual as larguras de caractere são retornadas.

lpabc
Aponta para uma matriz de ABC estruturas que recebem as larguras de caractere quando a função retorna. Essa matriz deve conter pelo menos a mesma quantidade de estruturas ABC quanto de caracteres no intervalo especificado pelos parâmetros nFirstChar e nLastChar.

lpABCF
Aponta para um buffer fornecido pelo aplicativo com uma matriz de estruturas ABCFLOAT para receber as larguras de caractere quando a função retorna. As larguras retornadas por essa função estão no formato de ponto flutuante IEEE.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

As larguras são retornadas em unidades lógicas. Essa função só tem êxito com fontes TrueType.

O rasterizador TrueType fornece espaçamento de caracteres "ABC" depois que um tamanho de ponto específico foi selecionado. O espaçamento "A" é a distância adicionada à posição atual antes de colocar o glifo. O espaçamento "B" é a largura da parte preta do glifo. O espaçamento "C" é adicionado à posição atual para considerar o espaço em branco à direita do glifo. A largura avançada total é fornecida por A + B + C.

Quando a função de membro GetCharABCWidths recupera larguras "A" ou "C" negativas para um caractere, esse caractere inclui pendências ou saliências.

Para converter as larguras ABC em unidades de design de fonte, um aplicativo deve criar uma fonte cuja altura (conforme especificado no membro lfHeight da estrutura LOGFONT) é igual ao valor armazenado no membro ntmSizeEM da estrutura NEWTEXTMETRIC. (O valor do membro ntmSizeEM pode ser recuperado chamando a função Windows EnumFontFamilies.)

As larguras ABC do caractere padrão são usadas para caracteres que estão fora do intervalo da fonte selecionada no momento.

Para recuperar as larguras dos caracteres em fontes não TrueType, os aplicativos devem usar a função Windows GetCharWidth.

CDC::GetCharABCWidthsI

Recupera as larguras, em unidades lógicas, de índices de glifo consecutivos em um intervalo especificado da fonte TrueType atual.

BOOL GetCharABCWidthsI(
    UINT giFirst,
    UINT cgi,
    LPWORD pgi,
    LPABC lpabc) const;

Parâmetros

giFirst
Especifica o primeiro índice de glifo no grupo de índices de glifo consecutivos da fonte atual. Esse parâmetro será útil apenas se o parâmetro pgi for definido como NULL.

cgi
Especifica o número de índices de glifo.

pgi
Um ponteiro para uma matriz que contém índices de glifo. Se o valor for NULL, o parâmetro giFirst será usado em vez disso. O parâmetro cgi especifica o número de índices de glifo nesta matriz.

lpabc
Ponteiro para uma matriz de estruturas ABC que recebem as larguras de caractere. Essa matriz deve conter pelo menos a mesma quantidade de estruturas ABC quanto de índices de glifo especificados pelo parâmetro cgi.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função membro emula a funcionalidade da função GetCharABCWidthsI, conforme descrito no SDK do Windows.

CDC::GetCharWidth

Recupera as larguras de caracteres individuais em um grupo consecutivo de caracteres da fonte atual usando m_hAttribDC, o contexto do dispositivo de saída.

BOOL GetCharWidth(
    UINT nFirstChar,
    UINT nLastChar,
    LPINT lpBuffer) const;

BOOL GetCharWidth(
    UINT nFirstChar,
    UINT nLastChar,
    float* lpFloatBuffer) const;

Parâmetros

nFirstChar
Especifica o primeiro caractere em um grupo consecutivo de caracteres na fonte atual.

nLastChar
Especifica o último caractere em um grupo consecutivo de caracteres na fonte atual.

lpBuffer
Aponta para um buffer que receberá os valores de largura de um grupo consecutivo de caracteres na fonte atual.

lpFloatBuffer
Aponta para um buffer para receber as larguras de caractere. As larguras retornadas estão no formato de ponto flutuante IEEE de 32 bits. (As larguras são medidas ao longo da linha base dos caracteres.)

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Por exemplo, se nFirstChar identificar a letra 'a' e nLastChar identificar a letra 'z', a função recuperará as larguras de todos os caracteres minúsculos.

A função armazena os valores no buffer apontado por lpBuffer. Esse buffer deve ser grande o suficiente para manter todas as larguras. Ou seja, deve haver pelo menos 26 entradas no exemplo dado.

Se um caractere no grupo consecutivo de caracteres não existir em uma fonte específica, ele receberá o valor de largura do caractere padrão.

CDC::GetCharWidthI

Recupera as larguras, em coordenadas lógicas, de índices de glifo consecutivos em um intervalo especificado da fonte atual.

BOOL GetCharWidthI(
    UINT giFirst,
    UINT cgi,
    LPWORD pgi,
    LPINT lpBuffer) const;

Parâmetros

giFirst
Especifica o primeiro índice de glifo no grupo de índices de glifo consecutivos da fonte atual. Esse parâmetro será útil apenas se o parâmetro pgi for definido como NULL.

cgi
Especifica o número de índices de glifo.

pgi
Um ponteiro para uma matriz que contém índices de glifo. Se o valor for NULL, o parâmetro giFirst será usado em vez disso. O parâmetro cgi especifica o número de índices de glifo nesta matriz.

lpBuffer
Um ponteiro para um buffer que recebe as larguras.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função membro emula a funcionalidade da função GetCharWidthI, conforme descrito no SDK do Windows.

CDC::GetClipBox

Recupera as dimensões do retângulo delimitador mais apertado ao redor do limite de recorte atual.

virtual int GetClipBox(LPRECT lpRect) const;

Parâmetros

lpRect
Aponta para a estrutura RECT ou objeto CRect que deve receber as dimensões do retângulo.

Valor de Devolução

O tipo da área de recorte. Pode ser qualquer um dos seguintes valores:

  • COMPLEXREGION A área de recorte tem bordas sobrepostas.

  • ERROR O contexto do dispositivo não é válido.

  • NULLREGION A área de recorte está vazia.

  • SIMPLEREGION A área de recorte não tem bordas sobrepostas.

Comentários

As dimensões são copiadas para o buffer apontado por lpRect.

CDC::GetColorAdjustment

Recupera os valores de ajuste de cor para o contexto do dispositivo.

BOOL GetColorAdjustment(LPCOLORADJUSTMENT lpColorAdjust) const;

Parâmetros

lpColorAdjust
Aponta para uma estrutura COLORADJUSTMENT de dados para receber os valores de ajuste de cor.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

CDC::GetCurrentBitmap

Retorna um ponteiro para o objeto CBitmap selecionado atualmente.

CBitmap* GetCurrentBitmap() const;

Valor de Devolução

Um ponteiro para um objeto CBitmap se tiver êxito; caso contrário, NULL.

Comentários

Essa função de membro pode retornar objetos temporários.

CDC::GetCurrentBrush

Retorna um ponteiro para o objeto CBrush selecionado atualmente.

CBrush* GetCurrentBrush() const;

Valor de Devolução

Um ponteiro para um objeto CBrush se tiver êxito; caso contrário, NULL.

Comentários

Essa função de membro pode retornar objetos temporários.

CDC::GetCurrentFont

Retorna um ponteiro para o objeto CFont selecionado atualmente.

CFont* GetCurrentFont() const;

Valor de Devolução

Um ponteiro para um objeto CFont se tiver êxito; caso contrário, NULL.

Comentários

Essa função de membro pode retornar objetos temporários.

CDC::GetCurrentPalette

Retorna um ponteiro para o objeto CPalette selecionado atualmente.

CPalette* GetCurrentPalette() const;

Valor de Devolução

Um ponteiro para um objeto CPalette se tiver êxito; caso contrário, NULL.

Comentários

Essa função de membro pode retornar objetos temporários.

CDC::GetCurrentPen

Retorna um ponteiro para o objeto CPen selecionado atualmente.

CPen* GetCurrentPen() const;

Valor de Devolução

Um ponteiro para um objeto CPen se tiver êxito; caso contrário, NULL.

Comentários

Essa função de membro pode retornar objetos temporários.

CDC::GetCurrentPosition

Recupera a posição atual (em coordenadas lógicas).

CPoint GetCurrentPosition() const;

Valor de Devolução

A posição atual como um objeto CPoint.

Comentários

A posição atual pode ser definida com a função de membro MoveTo.

CDC::GetDCBrushColor

Recupera a cor atual do pincel.

COLORREF GetDCBrushColor() const;

Valor de Devolução

Se a função for bem-sucedida, o valor retornado será o valor COLORREF para a cor atual do pincel.

Se a função falhar, o valor retornado será CLR_INVALID.

Comentários

Essa função membro emula a funcionalidade da função GetDCBrushColor, conforme descrito no SDK do Windows.

CDC::GetDCPenColor

Recupera a cor atual da caneta.

COLORREF GetDCPenColor() const;

Valor de Devolução

Se a função for bem-sucedida, o valor retornado será o valor COLORREF para a cor atual da caneta.

Se a função falhar, o valor retornado será CLR_INVALID.

Comentários

Essa função de membro utiliza a função do Win32 GetDCPenColor, conforme descrito no SDK do Windows.

CDC::GetDeviceCaps

Recupera uma ampla gama de informações específicas do dispositivo sobre o dispositivo de exibição.

int GetDeviceCaps(int nIndex) const;

Parâmetros

nIndex
Especifica o tipo de informação a ser retornada. Confira GetDeviceCaps no SDK do Windows uma lista de valores.

Valor de Devolução

O valor da funcionalidade solicitada se a função for bem-sucedida.

Exemplo

Confira o exemplo de CPrintDialog::GetDefaults.

CDC::GetFontData

Recupera informações de métrica de fonte de um arquivo de fonte escalonável.

DWORD GetFontData(
    DWORD dwTable,
    DWORD dwOffset,
    LPVOID lpData,
    DWORD cbData) const;

Parâmetros

dwTable
Especifica o nome da tabela de métrica a ser retornada. Esse parâmetro pode ser uma das tabelas de métrica documentadas na especificação Arquivos de Fonte TrueType publicada pela Microsoft Corporation. Se esse parâmetro for 0, as informações serão recuperadas a partir do início do arquivo de fonte.

dwOffset
Especifica o deslocamento do início da tabela no qual começar a recuperar informações. Se esse parâmetro for 0, as informações serão recuperadas a partir do início da tabela especificada pelo parâmetro dwTable. Se esse valor for maior ou igual ao tamanho da tabela, GetFontData retornará 0.

lpData
Aponta para um buffer que receberá as informações da fonte. Se esse valor for NULL, a função retornará o tamanho do buffer necessário para os dados de fonte especificados no parâmetro dwTable.

cbData
Especifica o tamanho, em bytes, das informações que serão recuperadas. Se esse parâmetro for 0, GetFontData retornará o tamanho dos dados especificados no parâmetro dwTable.

Valor de Devolução

Especifica o número de bytes retornados no buffer apontado por lpData se a função for bem-sucedida; caso contrário, -1.

Comentários

As informações a serem recuperadas são identificadas especificando um deslocamento para o arquivo de fonte e o comprimento das informações a serem retornadas.

Às vezes, um aplicativo pode usar a função de membro GetFontData para salvar uma fonte TrueType com um documento. Para fazer isso, o aplicativo determina se a fonte pode ser inserida e, em seguida, recupera todo o arquivo de fonte, especificando 0 para os parâmetros dwTable, dwOffset e cbData.

Os aplicativos podem determinar se uma fonte pode ser inserida verificando o membro otmfsType da estrutura OUTLINETEXTMETRIC. Se o bit 1 de otmfsType estiver definido, a incorporação não será permitida para a fonte. Se o bit 1 estiver claro, a fonte poderá ser inserida. Se o bit 2 estiver definido, a inserção será somente leitura.

Se um aplicativo tentar usar essa função para recuperar informações para uma fonte não TrueType, a função de membro GetFontData retornará -1.

CDC::GetFontLanguageInfo

Retorna informações sobre a fonte selecionada no momento para o contexto de exibição especificado.

DWORD GetFontLanguageInfo() const;

Valor de Devolução

O valor retornado identifica características da fonte selecionada no momento. Para obter uma lista completa de valores possíveis, consulte GetFontLanguageInfo.

Comentários

Essa função membro emula a funcionalidade da função GetFontLanguageInfo, conforme descrito no SDK do Windows.

CDC::GetGlyphOutline

Recupera a curva da estrutura de tópicos ou o bitmap para um caractere de estrutura de tópicos na fonte atual.

DWORD GetGlyphOutline(
    UINT nChar,
    UINT nFormat,
    LPGLYPHMETRICS lpgm,
    DWORD cbBuffer,
    LPVOID lpBuffer,
    const MAT2* lpmat2) const;

Parâmetros

nChar
Especifica o caractere para o qual as informações devem ser retornadas.

nFormat
Especifica o formato no qual a função deve retornar informações. Pode ser um dos seguintes valores, ou 0:

Valor Significado
GGO_BITMAP Retorna o bitmap de glifo. Quando a função retorna, o buffer apontado por lpBuffer contém um bitmap de 1 bit por pixel cujas linhas começam em limites de palavra dupla.
GGO_NATIVE Retorna os pontos de dados de curva no formato nativo do rasterizador, usando unidades de dispositivo. Quando esse valor é especificado, qualquer transformação especificada em lpmat2 é ignorada.

Quando o valor de é 0, a função preenche uma GLYPHMETRICS estrutura, mas não retorna dados de estrutura de nFormat glifos.

lpgm
Aponta para uma estrutura GLYPHMETRICS que descreve o posicionamento do glifo na célula de caracteres.

cbBuffer
Especifica o tamanho do buffer no qual a função copia informações sobre o caractere de estrutura de tópicos. Se esse valor for 0 e o parâmetro nFormat for algum dos valores GGO_BITMAP ou GGO_NATIVE, a função retornará o tamanho necessário do buffer.

lpBuffer
Aponta para um buffer no qual a função copia informações sobre o caractere de estrutura de tópicos. Se nFormat especificar o valor GGO_NATIVE, as informações serão copiadas na forma e nas estruturas TTPOLYGONHEADER e TTPOLYCURVE. Se esse valor for NULL, e nFormat for o valor GGO_BITMAP ou GGO_NATIVE, a função retornará o tamanho necessário do buffer.

lpmat2
Aponta para uma estrutura MAT2 que contém uma matriz de transformação para o caractere. Esse parâmetro não pode ser NULL, mesmo quando o valor GGO_NATIVE é especificado para nFormat.

Valor de Devolução

O tamanho, em bytes, do buffer necessário para as informações recuperadas se cbBuffer for 0 ou lpBuffer for NULL. Caso contrário, será um valor positivo se a função for bem-sucedida ou -1 se houver um erro.

Comentários

Um aplicativo pode girar caracteres recuperados no formato bitmap especificando uma matriz de transformação 2 por 2 na estrutura apontada por lpmat2.

Um contorno de glifo é retornado como uma série de contornos. Cada contorno é definido por uma estrutura TTPOLYGONHEADER seguida por quantas estruturas TTPOLYCURVE forem necessárias para descrevê-la. Todos os pontos são retornados como estruturas POINTFX e representam posições absolutas, não movimentos relativos. O ponto de partida fornecido pelo membro pfxStart da estrutura TTPOLYGONHEADER é o ponto no qual a estrutura de tópicos de um contorno começa. As estruturas TTPOLYCURVE a seguir podem ser registros de polilinha ou registros de spline. Registros de polilinha são uma série de pontos; linhas desenhadas entre os pontos descrevem a estrutura de tópicos do caractere. Os registros spline representam as curvas quadráticas usadas por TrueType (ou seja, b-splines quadráticos).

CDC::GetGraphicsMode

Recupera o modo gráfico atual para o contexto do dispositivo especificado.

int GetGraphicsMode() const;

Valor de Devolução

Retorna o modo gráfico atual com êxito. Para obter uma lista dos valores que esse método pode retornar, consulte GetGraphicsMode.

Retorna 0 em caso de falha.

Para obter outras informações sobre o erro, chame GetLastError.

Comentários

Esse método encapsula a função GDI do Windows GetGraphicsMode.

CDC::GetHalftoneBrush

Chame essa função de membro para recuperar um pincel de meio tom.

static CBrush* PASCAL GetHalftoneBrush();

Valor de Devolução

Um ponteiro para um objeto CBrush se tiver êxito; caso contrário, NULL.

Comentários

Um pincel de meio tom mostra pixels que são alternadamente em primeiro plano e cores de plano de fundo para criar um padrão pontilhado. O diagrama a seguir mostra um exemplo de um padrão dithered criado por um pincel de meio-tom:

Diagram that shows how a dithered pen stroke is composed.

O diagrama mostra como a cor de plano de fundo de preto e a cor de primeiro plano de amarelo são combinadas em um padrão alternando os pixels preto e amarelo entre si para criar um traçado de caneta dithered.

CDC::GetKerningPairs

Recupera os pares de kerning de caracteres para a fonte selecionada no momento no contexto do dispositivo especificado.

int GetKerningPairs(
    int nPairs,
    LPKERNINGPAIR lpkrnpair) const;

Parâmetros

nPairs
Especifica o número de estruturas KERNINGPAIR apontadas por lpkrnpair. A função não copiará mais pares de kerning do que o especificado pelo nPairs.

lpkrnpair
Aponta para uma matriz de estruturas KERNINGPAIR que recebem os pares de kerning quando a função retorna. Essa matriz deve conter pelo menos quantas estruturas forem especificadas por nPairs. Se esse parâmetro for NULL, a função retornará o número total de pares de kerning para a fonte.

Valor de Devolução

Especifica o número de pares de kerning recuperados ou o número total de pares de kerning na fonte, se a função for bem-sucedida. Zero será retornado se a função falhar ou não houver pares de kerning para a fonte.

CDC::GetLayout

Chame essa função de membro para determinar o layout do texto e dos elementos gráficos de um contexto de dispositivo, como uma impressora ou um meta-arquivo.

DWORD GetLayout() const;

Valor de Devolução

Se tiver êxito, o layout sinaliza para o contexto atual do dispositivo. Caso contrário, GDI_ERROR. Para obter informações sobre erros estendidos, chame GetLastError. Para obter um lista de sinalizadores de layout, consulte CDC::SetLayout.

Comentários

O layout padrão é da esquerda para a direita.

CDC::GetMapMode

Recupera o modo de mapeamento atual.

int GetMapMode() const;

Valor de Devolução

Modo de mapeamento

Comentários

Para obter uma descrição dos modos de mapeamento, consulte a função de membro SetMapMode.

Observação

Se você chamar SetLayout para alterar o DC para o layout da direita para a esquerda, SetLayout alterará automaticamente o modo de mapeamento para MM_ISOTROPIC. Consequentemente, qualquer chamada subsequente para GetMapMode retornará MM_ISOTROPIC.

CDC::GetMiterLimit

Retorna o limite de malhete para o contexto do dispositivo.

float GetMiterLimit() const;

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O limite do malhete é usado ao desenhar linhas geométricas que têm junções de miter.

CDC::GetNearestColor

Retorna a cor sólida que melhor corresponde a uma cor lógica especificada.

COLORREF GetNearestColor(COLORREF crColor) const;

Parâmetros

crColor
Especifica a cor a ser correspondida.

Valor de Devolução

Um valor de cor RGB (vermelho, verde, azul) que define a cor sólida mais próxima do valor crColor que o dispositivo pode representar.

Comentários

O dispositivo determinado deve ser capaz de representar essa cor.

CDC::GetOutlineTextMetrics

Recupera informações de métrica de fonte para fontes TrueType.

UINT GetOutlineTextMetrics(
    UINT cbData,
    LPOUTLINETEXTMETRIC lpotm) const;

Parâmetros

lpotm
Aponta para uma matriz de estruturas OUTLINETEXTMETRIC. Se esse parâmetro for NULL, a função retornará o tamanho do buffer necessário para os dados de métrica recuperados.

cbData
Especifica o tamanho, em bytes, do buffer ao qual as informações são retornadas.

lpotm
Aponta para uma estrutura OUTLINETEXTMETRIC. Se esse parâmetro for NULL, a função retornará o tamanho do buffer necessário para as informações de métrica recuperadas.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

A estrutura OUTLINETEXTMETRIC contém a maioria das informações de métrica de fonte fornecidas com o formato TrueType, incluindo uma estrutura TEXTMETRIC. Os últimos quatro membros da estrutura OUTLINETEXTMETRIC são ponteiros para cadeias de caracteres. Os aplicativos devem alocar espaço para essas cadeias de caracteres, além do espaço necessário para os outros membros. Como não há limite imposto pelo sistema para o tamanho das cadeias de caracteres, o método mais simples para alocar memória é recuperar o tamanho necessário especificando NULL para na primeira chamada para lpotm a GetOutlineTextMetrics função.

CDC::GetOutputCharWidth

Usa o contexto de dispositivo de saída, m_hDC, e recupera as larguras de caracteres individuais em um grupo consecutivo de caracteres da fonte atual.

BOOL GetOutputCharWidth(
    UINT nFirstChar,
    UINT nLastChar,
    LPINT lpBuffer) const;

Parâmetros

nFirstChar
Especifica o primeiro caractere em um grupo consecutivo de caracteres na fonte atual.

nLastChar
Especifica o último caractere em um grupo consecutivo de caracteres na fonte atual.

lpBuffer
Aponta para um buffer que receberá os valores de largura de um grupo consecutivo de caracteres na fonte atual.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Por exemplo, se nFirstChar identificar a letra 'a' e nLastChar identificar a letra 'z', a função recuperará as larguras de todos os caracteres minúsculos.

A função armazena os valores no buffer apontado por lpBuffer. Esse buffer deve ser grande o suficiente para manter todas as larguras; ou seja, deve haver pelo menos 26 entradas no exemplo dado.

Se um caractere no grupo consecutivo de caracteres não existir em uma fonte específica, ele receberá o valor de largura do caractere padrão.

CDC::GetOutputTabbedTextExtent

Chame essa função de membro para calcular a largura e a altura de uma cadeia de caracteres usando m_hDC, o contexto de dispositivo de saída.

CSize GetOutputTabbedTextExtent(
    LPCTSTR lpszString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions) const;

CSize GetOutputTabbedTextExtent(
    const CString& str,
    int nTabPositions,
    LPINT lpnTabStopPositions) const;

Parâmetros

lpszString
Aponta para uma cadeia de caracteres a ser medida. Você também pode passar um objeto CString para esse parâmetro.

nCount
Especifica o tamanho da cadeia de caracteres. apontada por lpszString.

nTabPositions
Especifica o número de posições de parada de tabulação na matriz apontada por lpnTabStopPositions.

lpnTabStopPositions
Aponta para uma matriz de inteiros que contém as posições tab-stop em unidades lógicas. As paradas de tabulação devem ser classificadas em ordem crescente; o menor valor x deve ser o primeiro item na matriz. Guias Voltar não são permitidas.

str
Um objeto CString que contém os caracteres especificados a serem medidas.

Valor de Devolução

As dimensões da cadeia de caracteres (em unidades lógicas) em um objeto CSize.

Comentários

Se a cadeia de caracteres contiver um ou mais caracteres de guia, a largura da cadeia de caracteres será baseada nas paradas de guia especificadas por lpnTabStopPositions. A função usa a fonte selecionada no momento para calcular as dimensões da cadeia de caracteres.

A região de recorte atual não desloca a largura e a altura retornadas pela GetOutputTabbedTextExtent função.

Como alguns dispositivos não colocam caracteres em matrizes de células regulares (ou seja, eles kern os caracteres), a soma das extensões dos caracteres em uma cadeia de caracteres pode não ser igual à extensão da cadeia de caracteres.

Se nTabPositions for 0 e lpnTabStopPositions for NULL, as guias serão expandidas para oito larguras médias de caracteres. Se nTabPositions for 1, as paradas de tabulação serão separadas pela distância especificada pelo primeiro valor na matriz para a qual lpnTabStopPositions aponta. Se lpnTabStopPositions apontar para mais de um único valor, uma parada de tabulação será definida para cada valor na matriz, até o número especificado por nTabPositions.

CDC::GetOutputTextExtent

Chame essa função de membro para usar o contexto de dispositivo de saída, m_hDC, e compute a largura e a altura de uma linha de texto usando a fonte atual.

CSize GetOutputTextExtent(
    LPCTSTR lpszString,
    int nCount) const;

CSize GetOutputTextExtent(const CString& str) const;

Parâmetros

lpszString
Aponta para uma cadeia de caracteres. Você também pode passar um objeto CString para esse parâmetro.

nCount
Especifica o tamanho da cadeia de caracteres. apontada por lpszString.

str
Um objeto CString que contém os caracteres especificados a serem medidas.

Valor de Devolução

As dimensões da cadeia de caracteres (em unidades lógicas) retornada em um objeto CSize.

Comentários

A região de recorte atual não afeta a largura e a altura retornadas pelo GetOutputTextExtent.

Como alguns dispositivos não colocam caracteres em matrizes de células regulares (ou seja, eles realizam kerning), a soma das extensões dos caracteres em uma cadeia de caracteres pode não ser igual à extensão da cadeia de caracteres.

CDC::GetOutputTextMetrics

Recupera as métricas da fonte atual usando m_hDC, o contexto do dispositivo de saída.

BOOL GetOutputTextMetrics(LPTEXTMETRIC lpMetrics) const;

Parâmetros

lpMetrics
Aponta para a estrutura TEXTMETRIC que recebe a métrica.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

CDC::GetPath

Recupera as coordenadas que definem os pontos de extremidade das linhas e os pontos de controle das curvas encontradas no caminho selecionado no contexto do dispositivo.

int GetPath(
    LPPOINT lpPoints,
    LPBYTE lpTypes,
    int nCount) const;

Parâmetros

lpPoints
Aponta para uma matriz de estruturas de dados POINT ou objetos CPoint, em que os pontos de extremidade de linha e pontos de controle de curva são colocados.

lpTypes
Aponta para uma matriz de bytes em que os tipos de vértice são colocados. Os valores são um dos seguintes:

  • PT_MOVETO Especifica que o ponto correspondente em lpPoints inicia uma figura desarticulada.

  • PT_LINETO Especifica que o ponto anterior e o ponto lpPoints correspondente são os pontos de extremidade de uma linha.

  • PT_BEZIERTO Especifica que o ponto correspondente em lpPoints é um ponto de controle ou ponto final para uma curva Bzier.

Tipos PT_BEZIERTO sempre ocorrem em conjuntos de três. O ponto no caminho imediatamente anterior a eles define o ponto de partida para a curva Bzier. Os dois primeiros pontos PT_BEZIERTO são os pontos de controle e o terceiro ponto PT_BEZIERTO é o ponto final (se codificado).

Um tipo PT_LINETO ou PT_BEZIERTO pode ser combinado com o seguinte sinalizador (usando o operador OR bit a bit) para indicar que o ponto correspondente é o último ponto em uma figura e que a figura deve ser fechada:

  • PT_CLOSEFIGURE Especifica que a figura é fechada automaticamente depois que a linha ou a curva correspondente é desenhada. A figura é fechada desenhando uma linha do ponto de extremidade de linha ou curva até o ponto correspondente ao último PT_MOVETO.

nCount
Especifica o número total de estruturas de dados POINT que podem ser colocadas na matriz lpPoints. Esse valor deve ser o mesmo que o número de bytes que podem ser colocados na matriz lpTypes.

Valor de Devolução

Se o parâmetro nCount não for zero, o número de pontos enumerados. Se nCount for 0, o número total de pontos no caminho (e GetPath não gravará nada nos buffers). Se nCount não for zero e for menor que o número de pontos no caminho, o valor retornado será -1.

Comentários

O contexto do dispositivo deve conter um caminho fechado. Os pontos do caminho são retornados em coordenadas lógicas. Os pontos são armazenados no caminho nas coordenadas do dispositivo, portanto, GetPath altera os pontos das coordenadas do dispositivo para as coordenadas lógicas usando o inverso da transformação atual. A função de membro FlattenPath pode ser chamada antes de GetPath para converter todas as curvas no caminho em segmentos de linha.

Exemplo

Confira o exemplo de CDC::BeginPath.

CDC::GetPixel

Recupera o valor de cor RGB do pixel no ponto especificado por x e *y*.

COLORREF GetPixel(
    int x,
    int y) const;

COLORREF GetPixel(POINT point) const;

Parâmetros

x
Especifica a coordenada x lógica do ponto a ser examinado.

y
Especifica a coordenada y lógica do ponto a ser examinado.

point
Especifica as coordenadas lógicas x e y do ponto a ser examinado.

Valor de Devolução

Para qualquer versão da função, um valor de cor RGB para a cor do ponto especificado. É -1 se as coordenadas não especificarem um ponto na região de recorte.

Comentários

O ponto deve estar na área de recorte. Se o ponto não estiver na região de recorte, a função não terá efeito e retornará -1.

Nem todos os dispositivos oferecem suporte à função GetPixel. Para obter mais informações, consulte a funcionalidade de varredura RC_BITBLT na função de membro GetDeviceCaps.

A função de membro GetPixel tem duas formas. O primeiro usa dois valores de coordenadas; o segundo usa uma estrutura POINT ou um objeto CPoint.

CDC::GetPolyFillMode

Recupera o modo de preenchimento de polígono atual.

int GetPolyFillMode() const;

Valor de Devolução

O modo atual preenchido por polígono, ALTERNATE ou WINDING, se a função for bem-sucedida.

Comentários

Consulte a função de membro SetPolyFillMode para obter uma descrição dos modos de preenchimento de polígono.

CDC::GetROP2

Recupera o modo de desenho atual.

int GetROP2() const;

Valor de Devolução

O modo de desenho. Para obter uma lista dos valores do modo de desenho, consulte a função de membro SetROP2.

Comentários

O modo de desenho especifica como as cores da caneta e o interior dos objetos preenchidos são combinados com a cor já na superfície de exibição.

CDC::GetSafeHdc

Chame essa função de membro para obter m_hDC, o contexto de dispositivo de saída.

HDC GetSafeHdc() const;

Valor de Devolução

Um identificador de contexto de dispositivo.

Comentários

Essa função de membro também funciona com ponteiros nulos.

CDC::GetStretchBltMode

Recupera o modo de alongamento de bitmap atual.

int GetStretchBltMode() const;

Valor de Devolução

O valor retornado especifica o modo atual de alongamento de bitmap, STRETCH_ANDSCANS, STRETCH_DELETESCANS ou STRETCH_ORSCANS, se a função for bem-sucedida.

Comentários

O modo de alongamento de bitmap define como as informações são removidas dos bitmaps que são estendidos ou compactados pela função de membro StretchBlt.

Normalmente, os modos STRETCH_ANDSCANS e STRETCH_ORSCANS são usados para preservar pixels em primeiro plano em bitmaps monocromáticos. Normalmente, o modo STRETCH_DELETESCANS é usado para preservar a cor em bitmaps de cor.

CDC::GetTabbedTextExtent

Chame essa função de membro para calcular a largura e a altura de uma cadeia de caracteres usando m_hAttribDC, o contexto de dispositivo de atributo.

CSize GetTabbedTextExtent(
    LPCTSTR lpszString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions) const;

CSize GetTabbedTextExtent(
    const CString& str,
    int nTabPositions,
    LPINT lpnTabStopPositions) const;

Parâmetros

lpszString
Aponta para uma cadeia de caracteres. Você também pode passar um objeto CString para esse parâmetro.

nCount
Especifica o tamanho da cadeia de caracteres. apontada por lpszString.

nTabPositions
Especifica o número de posições de parada de tabulação na matriz apontada por lpnTabStopPositions.

lpnTabStopPositions
Aponta para uma matriz de inteiros que contém as posições tab-stop em unidades lógicas. As paradas de tabulação devem ser classificadas em ordem crescente; o menor valor x deve ser o primeiro item na matriz. Guias Voltar não são permitidas.

str
Um objeto CString que contém os caracteres especificados a serem desenhados.

Valor de Devolução

As dimensões da cadeia de caracteres (em unidades lógicas) em um objeto CSize.

Comentários

Se a cadeia de caracteres contiver um ou mais caracteres de guia, a largura da cadeia de caracteres será baseada nas paradas de guia especificadas por lpnTabStopPositions. A função usa a fonte selecionada no momento para calcular as dimensões da cadeia de caracteres.

A região de recorte atual não desloca a largura e a altura retornadas pela GetTabbedTextExtent função.

Como alguns dispositivos não colocam caracteres em matrizes de células regulares (ou seja, eles kern os caracteres), a soma das extensões dos caracteres em uma cadeia de caracteres pode não ser igual à extensão da cadeia de caracteres.

Se nTabPositions for 0 e lpnTabStopPositions for NULL, as guias serão expandidas para oito vezes a largura média dos caracteres. Se nTabPositions for 1, as paradas de tabulação serão separadas pela distância especificada pelo primeiro valor na matriz para a qual lpnTabStopPositions aponta. Se lpnTabStopPositions apontar para mais de um único valor, uma parada de tabulação será definida para cada valor na matriz, até o número especificado por nTabPositions.

CDC::GetTextAlign

Recupera o status dos sinalizadores de alinhamento de texto para o contexto de dispositivo.

UINT GetTextAlign() const;

Valor de Devolução

O status dos sinalizadores de alinhamento de texto. O valor retornado é um ou mais dos seguintes valores:

  • TA_BASELINE Especifica o alinhamento do eixo x e a linha de base da fonte escolhida dentro do retângulo delimitador.

  • TA_BOTTOM Especifica o alinhamento do eixo x e a parte inferior do retângulo delimitador.

  • TA_CENTER Especifica o alinhamento do eixo y e o centro do retângulo delimitador.

  • TA_LEFT Especifica o alinhamento do eixo y e o lado esquerdo do retângulo delimitador.

  • TA_NOUPDATECP Especifica que a posição atual não é atualizada.

  • TA_RIGHT Especifica o alinhamento do eixo y e o lado direito do retângulo delimitador.

  • TA_TOP Especifica o alinhamento do eixo x e a parte superior do retângulo delimitador.

  • TA_UPDATECP Especifica que a posição atual está atualizada.

Comentários

Os sinalizadores de alinhamento de texto determinam como as funções de membro TextOut e ExtTextOutalinham uma cadeia de caracteres de texto em relação ao ponto de partida da cadeia de caracteres. Os sinalizadores de alinhamento de texto não são necessariamente sinalizadores de bit único e podem ser iguais a 0. Para testar se um sinalizador está definido, um aplicativo deve seguir essas etapas:

  1. Aplique o operador OR (|) bit a bit ao sinalizador e seus sinalizadores relacionados, agrupados da seguinte maneira:

    • TA_LEFT, TA_CENTER, e TA_RIGHT

    • TA_BASELINE, TA_BOTTOM, e TA_TOP

    • TA_NOUPDATECP e TA_UPDATECP

  2. Aplique o operador AND (&) bit a bit C++ ao resultado e ao valor retornado de GetTextAlign.

  3. Teste a igualdade desse resultado e o sinalizador.

CDC::GetTextCharacterExtra

Recupera a configuração atual para a quantidade de espaçamento entre caracteres.

int GetTextCharacterExtra() const;

Valor de Devolução

A quantidade de espaçamento entre caracteres.

Comentários

O GDI adiciona esse espaçamento a cada caractere, incluindo caracteres de interrupção, quando grava uma linha de texto no contexto do dispositivo.

O valor padrão da quantidade de espaçamento entre caracteres é 0.

CDC::GetTextColor

Recupera a cor do texto atual.

COLORREF GetTextColor() const;

Valor de Devolução

A cor do texto atual como um valor de cor RGB.

Comentários

A cor do texto é a cor de primeiro plano dos caracteres desenhados usando as funções de membro de saída de texto GDI TextOut, ExtTextOut e TabbedTextOut.

CDC::GetTextExtent

Chame essa função de membro para calcular a largura e a altura de uma linha de texto usando a fonte atual para determinar as dimensões.

CSize GetTextExtent(
    LPCTSTR lpszString,
    int nCount) const;

CSize GetTextExtent(const CString& str) const;

Parâmetros

lpszString
Aponta para uma cadeia de caracteres. Você também pode passar um objeto CString para esse parâmetro.

nCount
Especifica o número de caracteres na cadeia de caracteres.

str
Um objeto CString que contém os caracteres especificados.

Valor de Devolução

As dimensões da cadeia de caracteres (em unidades lógicas) em um objeto CSize.

Comentários

As informações são recuperadas de m_hAttribDC, o contexto de dispositivo de atributo.

Por padrão, GetTextExtent pressupõe que o texto para o qual ele recupera a dimensão seja definido ao longo de uma linha horizontal (ou seja, o escape é 0). Se você criar uma fonte especificando um escape diferente de zero, é preciso converter explicitamente o ângulo do texto para obter as dimensões da cadeia de caracteres.

A região de recorte atual não afeta a largura e a altura retornadas pelo GetTextExtent.

Como alguns dispositivos não colocam caracteres em matrizes de células regulares (ou seja, eles realizam kerning), a soma das extensões dos caracteres em uma cadeia de caracteres pode não ser igual à extensão da cadeia de caracteres.

CDC::GetTextExtentExPointI

Recupera o número de caracteres em uma cadeia de caracteres especificada que se ajustará a um espaço especificado e preenche uma matriz com a extensão de texto para cada um desses caracteres.

BOOL GetTextExtentExPointI(
    LPWORD pgiIn,
    int cgi,
    int nMaxExtent,
    LPINT lpnFit,
    LPINT alpDx,
    LPSIZE lpSize) const;

Parâmetros

pgiIn
Um ponteiro para uma matriz de índices de glifo para os quais as extensões devem ser recuperadas.

cgi
Especifica o número de glifos na matriz apontada por pgiIn.

nMaxExtent
Especifica a largura máxima permitida, em unidades lógicas, da cadeia de caracteres formatada.

lpnFit
Um ponteiro para um inteiro que recebe uma contagem do número máximo de caracteres que caberá no espaço especificado por nMaxExtent. Quando lpnFit é NULL, nMaxExtent é ignorado.

alpDx
Um ponteiro para uma matriz de inteiros que recebe extensões parciais de glifo. Cada elemento na matriz fornece a distância, em unidades lógicas, entre o início da matriz de índices de glifo e um dos glifos que se ajusta ao espaço especificado por nMaxExtent. Embora essa matriz deva ter pelo menos tantos elementos quanto os índices de glifo especificados por cgi, a função preenche a matriz com extensões apenas para a quantidade de índices de glifo especificada por lpnFit. Se lpnDx for NULL, a função não calcula larguras parciais de cadeia de caracteres.

lpSize
Ponteiro para uma estrutura SIZEque recebe as dimensões da matriz de índices de glifo, em unidades lógicas. Esse valor não pode ser NULL.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função membro emula a funcionalidade da função GetTextExtentExPointI, conforme descrito no SDK do Windows.

CDC::GetTextExtentPointI

Recupera a largura e a altura da matriz especificada de índices de glifo.

BOOL GetTextExtentPointI(
    LPWORD pgiIn,
    int cgi,
    LPSIZE lpSize) const;

Parâmetros

pgiIn
Um ponteiro para uma matriz de índices de glifo para os quais as extensões devem ser recuperadas.

cgi
Especifica o número de glifos na matriz apontada por pgiIn.

lpSize
Ponteiro para uma estrutura SIZEque recebe as dimensões da matriz de índices de glifo, em unidades lógicas. Esse valor não pode ser NULL.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função membro emula a funcionalidade da função GetTextExtentPointI, conforme descrito no SDK do Windows.

CDC::GetTextFace

Chame essa função de membro para copiar o nome de tipo da fonte atual em um buffer.

int GetTextFace(
    int nCount,
    LPTSTR lpszFacename) const;

int GetTextFace(CString& rString) const;

Parâmetros

nCount
Especifica o tamanho do buffer (em bytes). Se o nome da face de tipos for maior que o número de bytes especificados por esse parâmetro, o nome será truncado.

lpszFacename
Aponta para o buffer do nome da face de tipos.

rString
Uma referência a um objeto CString.

Valor de Devolução

O número de bytes copiado para o buffer, sem incluir o caractere nulo de terminação. É 0 se ocorrer um erro.

Comentários

O nome da face de tipos é copiado como uma cadeia de caracteres terminada em nulo.

CDC::GetTextMetrics

Recupera as métricas da fonte atual usando o contexto de dispositivo de atributo.

BOOL GetTextMetrics(LPTEXTMETRIC lpMetrics) const;

Parâmetros

lpMetrics
Aponta para a estrutura TEXTMETRIC que recebe a métrica.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

CDC::GetViewportExt

Recupera as extensões x e y do visor de contexto do dispositivo.

CSize GetViewportExt() const;

Valor de Devolução

As extensões x e y (em unidades de dispositivo) como um objeto CSize.

CDC::GetViewportOrg

Recupera as coordenadas x e y da origem do visor associado ao contexto do dispositivo.

CPoint GetViewportOrg() const;

Valor de Devolução

A origem do visor (nas coordenadas do dispositivo) como um objeto CPoint.

CDC::GetWindow

Retorna a janela associada ao contexto do dispositivo de exibição.

CWnd* GetWindow() const;

Valor de Devolução

Um ponteiro para um objeto CWnd, se tiver êxito; caso contrário, NULL.

Comentários

Essa é uma função avançada. Por exemplo, essa função de membro pode não retornar a janela de exibição ao imprimir ou na visualização de impressão. Ela sempre retorna a janela associada à saída. Funções de saída que usam o desenho de DC especificado nessa janela.

CDC::GetWindowExt

Recupera as extensões x e y da janela associada ao contexto de dispositivo.

CSize GetWindowExt() const;

Valor de Devolução

As extensões x e y (em unidades de dispositivo) como um objeto CSize.

CDC::GetWindowOrg

Recupera as coordenadas x e y da origem da janela associada ao contexto de dispositivo.

CPoint GetWindowOrg() const;

Valor de Devolução

A origem da janela (em coordenadas lógicas) como um objeto CPoint.

CDC::GetWorldTransform

Recupera o espaço do mundo atual para a transformação de espaço de página.

BOOL GetWorldTransform(XFORM& rXform) const;

Parâmetros

rXform
Referência a uma estrutura XFORM que recebe o espaço mundial atual para a transformação de espaço de página.

Valor de Devolução

Retorna um valor diferente de zero se tiver êxito.

Retorna 0 em caso de falha.

Para obter outras informações sobre o erro, chame GetLastError.

Comentários

Esse método encapsula a função GDI do Windows GetWorldTransform.

CDC::GradientFill

Chame essa função de membro para preencher estruturas de retângulo e triângulo com cor que desaparece suavemente de um lado para o outro.

BOOL GradientFill(
    TRIVERTEX* pVertices,
    ULONG nVertices,
    void* pMesh,
    ULONG nMeshElements,
    DWORD dwMode);

Parâmetros

pVertices
Ponteiro para uma matriz de estruturas TRIVERTEX que definem o vértice de um triângulo.

nVertices
O número de vértices.

pMesh
Matriz de estruturas GRADIENT_TRIANGLE no modo triângulo ou uma matriz de estruturas GRADIENT_RECT no modo retângulo.

nMeshElements
O número de elementos (triângulos ou retângulos) em pMesh.

dwMode
Especifica o modo de preenchimento de gradiente. Para obter uma lista de valores possíveis, consulte GradientFill no SDK do Windows.

Valor de Devolução

TRUE se for bem-sucedido, caso contrário, FALSE.

Comentários

Para obter mais informações, consulte GradientFill no SDK do Windows.

CDC::GrayString

Desenha texto esmaecido (cinza) no local determinado escrevendo o texto em um bitmap de memória, escurecendo o bitmap e copiando o bitmap para a exibição.

virtual BOOL GrayString(
    CBrush* pBrush,
    BOOL (CALLBACK* lpfnOutput)(
    HDC,
    LPARAM,
    int),
    LPARAM lpData,
    int nCount,
    int x,
    int y,
    int nWidth,
    int nHeight);

Parâmetros

pBrush
Identifica o pincel a ser usado para esmaecer (acinzentar).

lpfnOutput
Especifica o endereço de instância de procedimento da função de retorno de chamada fornecida pelo aplicativo que desenhará a cadeia de caracteres. Para obter mais informações, consulte a descrição da OutputFuncfunção de retorno de chamada do Windows. Se esse parâmetro for NULL, o sistema usará a função TextOut do Windows para desenhar a cadeia de caracteres, e lpData será considerado um ponteiro longo para a cadeia de caracteres a ser saída.

lpData
Especifica um ponteiro distante para os dados a serem passados para a função de saída. Se lpfnOutput for NULL, lpData deve ser um ponteiro longo para a cadeia de caracteres que será a saída.

nCount
Especifica o número de caracteres que serão a saída. Se esse parâmetro for 0, GrayString calculará o comprimento da cadeia de caracteres (supondo que lpData seja um ponteiro para a cadeia de caracteres). Se nCount for 1 e a função apontada por lpfnOutput retornar 0, a imagem será mostrada, mas não esmaecida.

x
Especifica a coordenada x lógica da posição inicial do retângulo que inclui a cadeia de caracteres.

y
Especifica a coordenada y lógica da posição inicial do retângulo que inclui a cadeia de caracteres.

nWidth
Especifica a largura (em unidades lógicas) do retângulo que inclui a cadeia de caracteres. Se nWidth for 0, GrayString calculará a largura da área, supondo que lpData seja um ponteiro para a cadeia de caracteres.

nHeight
Especifica a altura (em unidades lógicas) do retângulo que inclui a cadeia de caracteres. Se nHeight for 0, GrayString calculará a altura da área, supondo que lpData seja um ponteiro para a cadeia de caracteres.

Valor de Devolução

Não zero se a cadeia de caracteres for desenhada ou 0 se a função TextOut ou a função de saída fornecida pelo aplicativo retornar 0 ou se não houver memória suficiente para criar um bitmap de memória para esmaecimento.

Comentários

A função escurece o texto independentemente do pincel e da tela de fundo selecionados. A função de membro GrayString usa a fonte selecionada no momento. O modo de mapeamento de MM_TEXT deve ser selecionado antes de usar essa função.

Um aplicativo pode desenhar cadeias de caracteres esmaecidas (esmaecidas) em dispositivos que dão suporte a uma cor cinza sólida sem chamar a função de membro GrayString. A cor do sistema COLOR_GRAYTEXT é a cor do sistema cinza sólido usada para desenhar texto desabilitado. O aplicativo pode chamar a função do Windows GetSysColor para recuperar o valor de cor de COLOR_GRAYTEXT. Se a cor for diferente de 0 (preto), o aplicativo poderá chamar a função de membro para definir a cor do texto para o valor da cor e, em seguida, desenhar a SetTextColor cadeia de caracteres diretamente. Se a cor recuperada for preto, o aplicativo deverá chamar GrayString para escurecer (acinzentar) o texto.

Se lpfnOutput for NULL, o GDI usa a função do Windows TextOut e lpData é considerado um ponteiro distante para o caractere a ser saída. Se os caracteres que serão a saída não puderem ser manipulados pela função de membro TextOut (por exemplo, a cadeia de caracteres é armazenada como um bitmap), o aplicativo deve fornecer sua própria função de saída.

Todas as funções de retorno de chamada devem interceptar exceções do Microsoft Foundation antes de retornar ao Windows, já que as exceções não podem ser lançadas além dos limites de retorno de chamada. Para mais informações sobre exceções, confira o artigo Exceções.

A função de retorno de chamada passada para GrayString deve usar a convenção de chamada __stdcall e deve ser exportada com __declspec.

Quando a estrutura está no modo de visualização, uma chamada para a função de membro é convertida em uma TextOut chamada e a GrayString função de retorno de chamada não é chamada.

CDC::HIMETRICtoDP

Use essa função quando converter tamanhos HIMETRIC de OLE em pixels.

void HIMETRICtoDP(LPSIZE lpSize) const;

Parâmetros

lpSize
Aponta para uma estrutura SIZE ou um objeto CSize.

Comentários

Se o modo de mapeamento do objeto de contexto do dispositivo forMM_LOENGLISH, MM_HIENGLISH, MM_LOMETRICou MM_HIMETRIC, a conversão será baseada no número de pixels na polegada física. Se o modo de mapeamento for um dos outros modos não restritos (por exemplo, MM_TEXT), a conversão será baseada no número de pixels na polegada lógica.

CDC::HIMETRICtoLP

Chame essa função para converter unidades HIMETRIC em unidades lógicas.

void HIMETRICtoLP(LPSIZE lpSize) const;

Parâmetros

lpSize
Aponta para uma estrutura SIZE ou um objeto CSize.

Comentários

Use essa função quando você obtém tamanhos HIMETRIC do OLE e deseja convertê-los no modo de mapeamento natural do aplicativo.

A conversão é feita pela primeira vez convertendo as unidades HIMETRIC em pixels e convertendo essas unidades em unidades lógicas usando as unidades de mapeamento atuais do contexto do dispositivo. Observe que as extensões da janela e do visor do dispositivo afetarão o resultado.

CDC::IntersectClipRect

Cria uma nova área de recorte formando a interseção da área atual e um retângulo especificado por x1, y1, x2 e y2.

int IntersectClipRect(
    int x1,
    int y1,
    int x2,
    int y2);

int IntersectClipRect(LPCRECT lpRect);

Parâmetros

x1
Especifica a coordenada x lógica do canto superior esquerdo do retângulo.

y1
Especifica a coordenada y lógica do canto superior esquerdo do retângulo.

x2
Especifica a coordenada x lógica do canto inferior direito do retângulo.

y2
Especifica a coordenada y lógica do canto inferior direito do retângulo.

lpRect
Especifica o retângulo. Você pode passar um objeto CRect ou um ponteiro para uma estrutura RECT para esse parâmetro.

Valor de Devolução

O tipo da nova área de recorte. Pode ser qualquer um dos seguintes valores:

  • COMPLEXREGION A nova área de recorte tem bordas sobrepostas.

  • ERROR O contexto do dispositivo não é válido.

  • NULLREGION A nova área de recorte está vazia.

  • SIMPLEREGION A nova área de recorte não tem bordas sobrepostas.

Comentários

A GDI corta toda a saída subsequente para caber dentro do novo limite. A largura e a altura não devem exceder 32.767.

CDC::InvertRect

Inverte o conteúdo do retângulo especificado.

void InvertRect(LPCRECT lpRect);

Parâmetros

lpRect
Aponta para um RECT que contém as coordenadas lógicas do retângulo a ser invertido. Você também pode passar um objeto CRect para esse parâmetro.

Comentários

A inversão é uma operação NOT lógica e inverte os bits de cada pixel. Em exibições monocromáticas, a função torna os pixels brancos em pretos, e os pretos em branco. Em exibições de cores, a inversão depende de como as cores são geradas para a exibição. Chamar InvertRect duas vezes com o mesmo retângulo restaura a exibição para suas cores anteriores.

Se o retângulo estiver vazio, nada será desenhado.

Exemplo

void CDCView::DoInvertRect(CDC *pDC)
{
   // invert rect from 20,20 to 50,50
   CRect rect(20, 20, 50, 50);
   pDC->InvertRect(rect);

   // inverting again restores to normal
   ::Sleep(1000);
   pDC->InvertRect(rect);
}

CDC::InvertRgn

Inverte as cores na região especificada por pRgn.

BOOL InvertRgn(CRgn* pRgn);

Parâmetros

pRgn
Identifica a região a ser invertida. As coordenadas da região são especificadas em unidades lógicas.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Em exibições monocromáticas, a função torna os pixels brancos em pretos, e os pretos em branco. Em exibições de cores, a inversão depende de como as cores são geradas para a exibição.

CDC::IsPrinting

Determina se o contexto do dispositivo está sendo usado para impressão.

BOOL IsPrinting() const;

Valor de Devolução

Diferente de zero se o objeto CDC for um DC de impressora; caso contrário, 0.

CDC::LineTo

Desenha uma linha da posição atual até o ponto especificado por x e y (ou point), mas sem incluí-lo.

BOOL LineTo(
    int x,
    int y);

BOOL LineTo(POINT point);

Parâmetros

x
Especifica a coordenada x lógica do ponto de extremidade da linha.

y
Especifica a coordenada y lógica do ponto de extremidade da linha.

point
Especifica o ponto de extremidade da linha. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Diferente de zero se a linha for desenhada; caso contrário, 0.

Comentários

A linha é desenhada com a caneta selecionada. A posição atual é definida como x, y ou como point.

Exemplo

Confira o exemplo de CRect::CenterPoint.

CDC::LPtoDP

Converte unidades lógicas em unidades de dispositivo.

void LPtoDP(
    LPPOINT lpPoints,
    int nCount = 1) const;

void LPtoDP(LPRECT lpRect) const;
void LPtoDP(LPSIZE lpSize) const;

Parâmetros

lpPoints
Aponta para uma matriz de pontos. Cada ponto na matriz é uma estrutura POINT ou um objeto CPoint.

nCount
O número de pontos na matriz.

lpRect
Aponta para uma estrutura RECT ou objeto CRect. Esse parâmetro é usado para o caso comum de mapeamento de um retângulo de unidades lógicas para dispositivos.

lpSize
Aponta para uma estrutura SIZE ou objeto CSize.

Comentários

A função mapeia as coordenadas de cada ponto, ou dimensão de um tamanho, do sistema de coordenadas do dispositivo para o sistema de coordenadas lógica de GDI. A conversão depende do modo de mapeamento atual e das configurações das origens e extensões da janela e do visor do dispositivo.

As coordenadas x e y dos pontos são inteiros com sinal de 2 bytes no intervalo -32.768 a 32.767. Nos casos em que o modo de mapeamento resultaria em valores maiores que esses limites, o sistema define os valores como -32.768 e 32.767, respectivamente.

CDC::LPtoHIMETRIC

Chame essa função para converter unidades lógicas em unidades HIMETRIC.

void LPtoHIMETRIC(LPSIZE lpSize) const;

Parâmetros

lpSize
Aponta para uma estrutura SIZE ou objeto CSize.

Comentários

Use essa função quando você fornecer tamanhos HIMETRIC ao OLE, convertendo do modo de mapeamento natural do aplicativo. As extensões da janela e do visor do dispositivo afetarão o resultado.

A conversão é alcançada primeiro por meio da conversão das unidades lógicas em pixels, usando as unidades de mapeamento atuais do contexto de dispositivo e, em seguida, convertendo essas unidades em unidades HIMETRIC.

CDC::m_hAttribDC

O contexto de dispositivo de atributo para esse objeto CDC.

HDC m_hAttribDC;

Comentários

Por padrão, esse contexto de dispositivo é igual a m_hDC. Em geral, CDC as chamadas GDI que solicitam informações do contexto do dispositivo são direcionadas para m_hAttribDC. Consulte a descrição da classe CDC para saber mais sobre o uso desses dois contextos de dispositivo.

CDC::m_hDC

O contexto de dispositivo de saída usado por esse objeto CDC.

HDC m_hDC;

Comentários

Por padrão, m_hDC é igual a m_hAttribDC, o outro contexto de dispositivo encapsulado por CDC. Em geral, as chamadas GDI CDC que criam saída vão para o contexto de dispositivo m_hDC. Você pode inicializar m_hDC e m_hAttribDC para apontar para dispositivos diferentes. Consulte a descrição da classe CDC para saber mais sobre o uso desses dois contextos de dispositivo.

CDC::MaskBlt

Combina os dados de cor para os bitmaps de origem e destino usando a operação de máscara e varredura dados.

BOOL MaskBlt(
    int x,
    int y,
    int nWidth,
    int nHeight,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    CBitmap& maskBitmap,
    int xMask,
    int yMask,
    DWORD dwRop);

Parâmetros

x
Especifica a coordenada x lógica do canto superior esquerdo do retângulo de destino.

y
Especifica a coordenada y lógica do canto superior esquerdo do retângulo de destino.

nWidth
Especifica a largura, em unidades lógicas, do retângulo de destino e do bitmap de origem.

nHeight
Especifica a altura, em unidades lógicas, do retângulo de destino e do bitmap de origem.

pSrcDC
Identifica o contexto do dispositivo do qual o bitmap deve ser copiado. Ele deve ser zero se o dwRop parâmetro especificar uma operação raster que não inclua uma origem.

xSrc
Especifica a coordenada x lógica do canto superior esquerdo do bitmap de origem.

ySrc
Especifica a coordenada y lógica do canto superior esquerdo do bitmap de origem.

maskBitmap
Identifica o bitmap de máscara monocromático combinado com o bitmap de cor no contexto do dispositivo de origem.

xMask
Especifica o deslocamento horizontal de pixel para o bitmap de máscara especificado pelo parâmetro maskBitmap.

yMask
Especifica o deslocamento vertical de pixel para o bitmap de máscara especificado pelo parâmetro maskBitmap.

dwRop
Especifica os códigos de operação de varredura ternária em primeiro plano e em segundo plano que a função usa para controlar a combinação de dados de origem e de destino. O código de operação de varredura em segundo plano é armazenado no byte alto da palavra alta desse valor; o código de operação de varredura em primeiro plano é armazenado no byte baixo da palavra alt desse valor; a palavra baixa desse valor é ignorada e deve ser zero. A macro MAKEROP4 cria essas combinações de códigos de operação de varredura em primeiro plano e em segundo plano. Consulte a seção Comentários para obter uma discussão sobre o primeiro plano e a tela de fundo no contexto dessa função. Consulte a função de membro BitBlt para obter uma lista de códigos de operação de varredura comuns.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Um valor de 1 na máscara especificada por maskBitmap indica que o código de operação de varredura em primeiro plano especificado por dwRop deve ser aplicado nesse local. Um valor de 0 na máscara indica que o código de operação de varredura em segundo plano especificado por dwRop deve ser aplicado nesse local. Se as operações de varredura exigirem uma origem, o retângulo da máscara deverá cobrir o retângulo de origem. Se isso não acontecer, a função falhará. Se as operações de raster não exigirem uma origem, o retângulo da máscara deverá cobrir o retângulo de destino. Se isso não acontecer, a função falhará.

Se uma transformação de rotação ou de tesoura estiver vigente para o contexto do dispositivo de origem quando essa função for chamada, ocorrerá um erro. No entanto, outros tipos de transformações são permitidos.

Se os formatos de cor dos bitmaps de origem, padrão e destino forem diferentes, essa função converterá o padrão ou o formato de origem, ou ambos, para corresponder ao formato de destino. Se o bitmap de máscara não for um bitmap monocromático, ocorrerá um erro. Quando um meta-arquivo aprimorado está sendo registrado, ocorre um erro (e a função retorna 0) se o contexto do dispositivo de origem identifica um contexto de dispositivo de meta-arquivo aprimorado. Nem todos os dispositivos dão suporte a MaskBlt. Um aplicativo deve chamar GetDeviceCaps para determinar se um dispositivo dá suporte a essa função. Se nenhum bitmap de máscara for fornecido, essa função se comportará exatamente como BitBlt, usando o código de operação de varredura em primeiro plano. Os deslocamentos de pixel no mapa de bitmap de máscara para o ponto (0,0) no bitmap do contexto do dispositivo de origem. Isso é útil para casos em que um bitmap de máscara contém um conjunto de máscaras; um aplicativo pode aplicar facilmente qualquer um deles a uma tarefa de mascaramento, ajustando os deslocamentos de pixel e os tamanhos de retângulo enviados para MaskBlt.

CDC::ModifyWorldTransform

Altera a transformação do mundo para um contexto de dispositivo usando o modo especificado.

BOOL ModifyWorldTransform(
    const XFORM& rXform,
    DWORD iMode);

Parâmetros

rXform
Referência a uma estrutura XFORM usada para modificar a transformação global para o contexto de dispositivo fornecido.

iMode
Especifica como os dados de transformação modificam a transformação global atual. Para obter uma lista dos valores que esse parâmetro pode usar, consulte ModifyWorldTransform.

Valor de Devolução

Retorna um valor diferente de zero se tiver êxito.

Retorna 0 em caso de falha.

Para obter outras informações sobre o erro, chame GetLastError.

Comentários

Esse método encapsula a função GDI do Windows ModifyWorldTransform.

CDC::MoveTo

Move a posição atual para o ponto especificado por x e y (ou por point).

CPoint MoveTo(
    int x,
    int y);

CPoint MoveTo(POINT point);

Parâmetros

x
Especifica a coordenada lógica x da nova posição.

y
Especifica a coordenada lógica y da nova posição.

point
Especifica a nova posição. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

As coordenadas x e y da posição anterior como um objeto CPoint.

Exemplo

Confira o exemplo de CRect::CenterPoint.

CDC::OffsetClipRgn

Move a região de recorte do contexto do dispositivo pelos deslocamentos especificados.

int OffsetClipRgn(
    int x,
    int y);

int OffsetClipRgn(SIZE size);

Parâmetros

x
Especifica o número de unidades lógicas a serem movidas para a esquerda ou para a direita.

y
Especifica o número de unidades lógicas a serem movidas para cima ou para baixo.

size
Especifica o valor a ser deslocado.

Valor de Devolução

O tipo da nova região. Pode ser qualquer um dos seguintes valores:

  • COMPLEXREGION A área de recorte tem bordas sobrepostas.

  • ERROR O contexto do dispositivo não é válido.

  • NULLREGION A área de recorte está vazia.

  • SIMPLEREGION A área de recorte não tem bordas sobrepostas.

Comentários

A função move as unidades x da região ao longo do eixo x e unidades y ao longo do eixo y.

CDC::OffsetViewportOrg

Modifica as coordenadas da origem do visor em relação às coordenadas da origem do visor atual.

virtual CPoint OffsetViewportOrg(
    int nWidth,
    int nHeight);

Parâmetros

nWidth
Especifica o número de unidades de dispositivo a serem adicionadas à coordenada x da origem atual.

nHeight
Especifica o número de unidades de dispositivo a serem adicionadas à coordenada y da origem atual.

Valor de Devolução

A origem anterior do visor (nas coordenadas do dispositivo) como um objeto CPoint.

CDC::OffsetWindowOrg

Modifica as coordenadas de origem da janela em relação às coordenadas da origem da janela atual.

CPoint OffsetWindowOrg(
    int nWidth,
    int nHeight);

Parâmetros

nWidth
Especifica o número de unidades lógicas de dispositivo a serem adicionadas à coordenada x da origem atual.

nHeight
Especifica o número de unidades lógicas de dispositivo a serem adicionadas à coordenada y da origem atual.

Valor de Devolução

A origem da janela anterior (em coordenadas lógicas) como um objeto CPoint.

CDC::operator HDC

Use esse operador para recuperar o identificador de contexto de dispositivo do objeto CDC.

operator HDC() const;

Valor de Devolução

Se tiver êxito, o identificador do objeto de contexto de dispositivo; caso contrário, NULL.

Comentários

Você pode usar o identificador para chamar as APIs do Windows diretamente.

CDC::PaintRgn

Preenche a região especificada por pRgn usando o pincel atual.

BOOL PaintRgn(CRgn* pRgn);

Parâmetros

pRgn
Identifica a região a ser invertida. As coordenadas para a região determinada são especificadas em unidades lógicas.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

CDC::PatBlt

Cria um padrão de bit no dispositivo.

BOOL PatBlt(
    int x,
    int y,
    int nWidth,
    int nHeight,
    DWORD dwRop);

Parâmetros

x
Especifica a coordenada x lógica do canto superior esquerdo do retângulo que deve receber o padrão.

y
Especifica a coordenada y lógica do canto superior esquerdo do retângulo que deve receber o padrão.

nWidth
Especifica a largura (em unidades lógicas) do retângulo que deve receber o padrão.

nHeight
Especifica a altura (em unidades lógicas) do retângulo que deve receber o padrão.

dwRop
Especifica o código de operação de varredura. Os códigos da operação de varredura definem como a GDI combina cores nas operações de saída que envolvem um pincel, um possível bitmap de origem e um bitmap de destino. Esse parâmetro pode usar um dos valores a seguir:

  • PATCOPY Copia o padrão para o bitmap de destino.

  • PATINVERT Combina o bitmap de destino com o padrão usando o operador XOR (^) booliano.

  • DSTINVERT Inverte o bitmap de destino.

  • BLACKNESS Faz com que toda a saída seja preta.

  • WHITENESS Faz com que toda a saída seja branca.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O padrão é uma combinação do pincel selecionado e do padrão que já está no dispositivo. O código de operação de varredura especificado por dwRop define como os padrões devem ser combinados. As operações de varredura listadas para essa função são um subconjunto limitado dos 256 códigos de operação de varredura ternários completos; em particular, um código de operação de varredura que se refere a uma fonte não pode ser usado.

Nem todos os contextos de dispositivo dão suporte à função PatBlt. Para determinar se um contexto de dispositivo oferece suporte a PatBlt, chame a função membro GetDeviceCaps com o índice RASTERCAPS e verifique o valor de retorno para o sinalizador RC_BITBLT.

CDC::Pie

Desenha uma cunha em forma de pizza desenhando um arco elíptico cujo centro e dois pontos de extremidade são unidos por linhas.

BOOL Pie(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3,
    int x4,
    int y4);

BOOL Pie(
    LPCRECT lpRect,
    POINT ptStart,
    POINT ptEnd);

Parâmetros

x1
Especifica a coordenada x do canto esquerdo superior do retângulo delimitador (em unidades lógicas).

y1
Especifica a coordenada y do canto esquerdo superior do retângulo delimitador (em unidades lógicas).

x2
Especifica a coordenada x do canto direito inferior do retângulo delimitador (em unidades lógicas).

y2
Especifica a coordenada y do canto direito inferior do retângulo delimitador (em unidades lógicas).

x3
Especifica a coordenada x do ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

y3
Especifica a coordenada y do ponto de partida do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

x4
Especifica a coordenada x do ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

y4
Especifica a coordenada y do ponto final do arco (em unidades lógicas). Esse ponto não precisa estar exatamente no arco.

lpRect
Especifica o retângulo delimitador. Você pode passar um objeto CRect ou um ponteiro para uma estrutura RECT para esse parâmetro.

ptStart
Especifica o ponto de partida do arco. Esse ponto não precisa estar exatamente no arco. Você pode passar uma POINT estrutura ou um CPoint objeto para esse parâmetro.

ptEnd
Especifica o ponto de extremidade do arco. Esse ponto não precisa estar exatamente no arco. Você pode passar uma POINT estrutura ou um CPoint objeto para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O centro do arco é o centro do retângulo delimitador especificado porx1, y1, x2 e y2 (ou por lpRect). Os pontos de partida e final do arco são especificados por x3, y3, x4 e y4 (ou por ptStart e ptEnd).

O arco é desenhado com a caneta selecionada, movendo-se em uma direção anti-horária. Mais duas linhas são desenhadas de cada ponto de extremidade para o centro do arco. A área em forma de pizza é preenchida com o pincel atual. Se x3 for igual a x4 e y3 for igual a y4, o resultado será uma elipse com uma única linha do centro da elipse até o ponto (x3, y3) ou (x4, y4).

A figura desenhada por essa função se estende até, mas não inclui as coordenadas direita e inferior. Isso significa que a altura da figura é y2 - y1 e a largura da figura é x2 - x1. A largura e a altura do retângulo delimitador devem ser maiores que 2 unidades e menos de 32.767 unidades.

Exemplo

void CDCView::DrawPie(CDC *pDC)
{
   // Fill the client area with a simple pie chart. A
   // big blue slice covers 75% of the pie, from
   // 6 o'clock to 3 o'clock. This portion is filled
   // with blue and has a blue edge. The remaining 25%
   // is filled with a red, diagonal hatch and has
   // a red edge.

   // Get the client area.
   CRect rectClient;
   GetClientRect(rectClient);

   // Make a couple of pens and similar brushes.
   CPen penBlue, penRed;
   CBrush brushBlue, brushRed;
   CBrush *pOldBrush;
   CPen *pOldPen;

   brushBlue.CreateSolidBrush(RGB(0, 0, 255));
   brushRed.CreateHatchBrush(HS_FDIAGONAL, RGB(255, 0, 0));
   penBlue.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(0, 0, 255));
   penRed.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(255, 0, 0));

   // Draw from 3 o'clock to 6 o'clock, counterclockwise,
   // in a blue pen with a solid blue fill.

   pOldPen = pDC->SelectObject(&penBlue);
   pOldBrush = pDC->SelectObject(&brushBlue);

   pDC->Pie(rectClient,
            CPoint(rectClient.right, rectClient.CenterPoint().y),
            CPoint(rectClient.CenterPoint().x, rectClient.right));

   // Draw the remaining quarter slice from 6 o'clock
   // to 3 o'clock, counterclockwise, in a red pen with
   // the hatched brush.
   pDC->SelectObject(&penRed);
   pDC->SelectObject(&brushRed);

   // Same parameters, but reverse start and end points.
   pDC->Pie(rectClient,
            CPoint(rectClient.CenterPoint().x, rectClient.right),
            CPoint(rectClient.right, rectClient.CenterPoint().y));

   // Restore the previous pen.
   pDC->SelectObject(pOldPen);
}

CDC::PlayMetaFile

Reproduz o conteúdo do meta-arquivo especificado no contexto de dispositivo.

BOOL PlayMetaFile(HMETAFILE hMF);

BOOL PlayMetaFile(
    HENHMETAFILE hEnhMetaFile,
    LPCRECT lpBounds);

Parâmetros

hMF
Identifica o meta-arquivo a ser reproduzido.

hEnhMetaFile
Identifica o meta-arquivo aprimorado.

lpBounds
Aponta para uma estrutura RECT ou um objeto CRect que contém as coordenadas do retângulo delimitador usado para exibir a imagem. As coordenadas são especificadas em unidades lógicas.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O meta-arquivo pode ser reproduzido várias vezes.

A segunda versão de PlayMetaFile exibe a imagem armazenada no meta-arquivo de formato aprimorado especificado. Quando um aplicativo chama a segunda versão de PlayMetaFile, o Windows usa o quadro de imagem no cabeçalho de meta-arquivo aprimorado para mapear a imagem para o retângulo apontado pelo parâmetro lpBounds. (Essa imagem pode ser desarmada ou girada por meio da definição da transformação global no dispositivo de saída antes de chamar PlayMetaFile.) Os pontos ao longo das bordas do retângulo estão incluídos na imagem. Uma imagem de meta-arquivo aprimorada pode ser recortada definindo a área de recorte no dispositivo de saída antes de reproduzir o meta-arquivo aprimorado.

Se um meta-arquivo aprimorado contiver uma paleta opcional, um aplicativo poderá obter cores consistentes configurando uma paleta de cores no dispositivo de saída antes de chamar a segunda versão de PlayMetaFile. Para recuperar a paleta opcional, use a função do Windows GetEnhMetaFilePaletteEntries. Um meta-arquivo aprimorado pode ser inserido em um meta-arquivo aprimorado recém-criado chamando a segunda versão PlayMetaFile e reproduzindo o meta-arquivo aprimorado de origem no contexto do dispositivo para o novo meta-arquivo aprimorado.

Os estados do contexto de dispositivo de saída são preservados por essa função. Qualquer objeto criado, mas não excluído no meta-arquivo aprimorado, é excluído por essa função. Para interromper essa função, um aplicativo pode chamar a função do Windows CancelDC de outro thread para encerrar a operação. Nesse caso, a função retorna zero.

CDC::PlgBlt

Executa uma transferência de bloco de bits dos bits de dados de cor do retângulo especificado no contexto do dispositivo de origem para o paralelograma especificado no contexto de dispositivo fornecido.

BOOL PlgBlt(
    LPPOINT lpPoint,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    int nWidth,
    int nHeight,
    CBitmap& maskBitmap,
    int xMask,
    int yMask);

Parâmetros

lpPoint
Aponta para uma matriz de três pontos no espaço lógico que identifica três cantos do paralelogramo de destino. O canto superior esquerdo do retângulo de origem é mapeado para o primeiro ponto nessa matriz, o canto superior direito para o segundo ponto nessa matriz e o canto inferior esquerdo para o terceiro ponto. O canto inferior direito do retângulo de origem é mapeado para o quarto ponto implícito no paralelogramo.

pSrcDC
Identifica o contexto do dispositivo de origem.

xSrc
Especifica a coordenada x, em unidades lógicas, do canto esquerdo superior do retângulo de origem.

ySrc
Especifica a coordenada y, em unidades lógicas, do canto esquerdo superior do retângulo de origem.

nWidth
Especifica a largura, em unidades lógicas, do retângulo de origem.

nHeight
Especifica a altura, em unidades lógicas, do retângulo de origem.

maskBitmap
Identifica um bitmap monocromático opcional que é usado para mascarar as cores do retângulo de origem.

xMask
Especifica a coordenada x do canto superior esquerdo do bitmap monocromático.

yMask
Especifica a coordenada y do canto superior esquerdo do bitmap monocromático.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Se o identificador do bitmask identificar um bitmap monocromático válido, a função usará esse bitmap para mascarar os bits de dados de cor do retângulo de origem.

O quarto vértice do paralelograma (D) é definido tratando os três primeiros pontos (A, B e C) como vetores e computando D = B + C – A.

Se a máscara de bits existir, um valor de 1 na máscara indica que a cor do pixel de origem deve ser copiada para o destino. Um valor 0 na máscara indica que a cor do pixel de destino não deve ser alterada.

Se o retângulo da máscara for menor que os retângulos de origem e destino, a função replicará o padrão da máscara.

Transformações de escala, tradução e reflexão são permitidas no contexto do dispositivo de origem; no entanto, as transformações de rotação e cisalhamento não são. Se o bitmap de máscara não for um bitmap monocromático, ocorrerá um erro. O modo de alongamento para o contexto do dispositivo de destino é usado para determinar como esticar ou compactar os pixels, se necessário. Quando um meta-arquivos aprimorado está sendo registrado, ocorre um erro se o contexto do dispositivo de origem identifica um contexto de dispositivo de meta-arquivo aprimorado.

As coordenadas de destino são transformadas de acordo com o contexto do dispositivo de destino; as coordenadas de origem são transformadas de acordo com o contexto do dispositivo de origem. Se a transformação de origem tiver uma rotação ou uma distorção, um erro será retornado. Se os retângulos de destino e de origem não tiverem o mesmo formato de cor, PlgBlt converte o retângulo de origem para corresponder ao retângulo de destino. Nem todos os dispositivos dão suporte a PlgBlt. Para obter mais informações, consulte a descrição da funcionalidade de varredura RC_BITBLT na função de membro CDC::GetDeviceCaps.

Se os contextos do dispositivo de origem e de destino representarem dispositivos incompatíveis, PlgBlt retornará um erro.

CDC::PolyBezier

Desenha um ou mais splines Bzier.

BOOL PolyBezier(
    const POINT* lpPoints,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas de dados POINT que contêm os pontos de extremidade e pontos de controle do(s) spline(s).

nCount
Especifica o número de pontos na matriz lpPoints. Esse valor deve ser mais de três vezes o número de splines a serem desenhados, porque cada spline Bzier requer dois pontos de controle e um ponto de extremidade, e o spline inicial requer outro ponto de partida.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função desenha splines Bzier cúbicos usando os pontos de extremidade e pontos de controle especificados pelo parâmetro lpPoints. O primeiro spline é desenhado do primeiro ponto para o quarto ponto usando o segundo e o terceiro pontos como pontos de controle. Cada spline subsequente na sequência precisa exatamente de mais três pontos: o ponto final do spline anterior é usado como ponto de partida, os próximos dois pontos na sequência são pontos de controle e o terceiro é o ponto final.

A posição atual não é usada ou atualizada pela PolyBezier função. O número não está preenchido. Essa função desenha linhas usando a caneta atual.

CDC::PolyBezierTo

Desenha um ou mais splines Bzier.

BOOL PolyBezierTo(
    const POINT* lpPoints,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas de dados POINT que contêm os pontos de extremidade e pontos de controle.

nCount
Especifica o número de pontos na matriz lpPoints. Esse valor deve ser três vezes o número de splines a serem desenhados, pois cada spline Bzier requer dois pontos de controle e um ponto de extremidade.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função desenha splines Bzier cúbicos usando os pontos de controle especificados pelo parâmetro lpPoints. O primeiro spline é desenhado da posição atual para o terceiro ponto usando os dois primeiros pontos como pontos de controle. Para cada spline subsequente, a função precisa exatamente de mais três pontos e usa o ponto de extremidade do spline anterior como o ponto de partida para o próximo. PolyBezierTo move a posição atual para o ponto final do último spline Bzier. O número não está preenchido. Essa função desenha linhas usando a caneta atual.

Exemplo

Confira o exemplo de CDC::BeginPath.

CDC::PolyDraw

Desenha um conjunto de segmentos de linha e splines Bzier.

BOOL PolyDraw(
    const POINT* lpPoints,
    const BYTE* lpTypes,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas de dados POINT que contém os pontos de extremidade para cada segmento de linha e os pontos de extremidade e pontos de controle para cada spline Bzier.

lpTypes
Aponta para uma matriz que especifica como cada ponto na matriz lpPoints é usado. Pode conter um dos seguintes valores:

  • PT_MOVETO Especifica que esse ponto inicia uma figura desarticulada. Esse ponto se torna a nova posição atual.

  • PT_LINETO Especifica que uma linha deve ser desenhada da posição atual para esse ponto, que então se torna a nova posição atual.

  • PT_BEZIERTO Especifica que esse ponto é um ponto de controle ou ponto final para um spline Bzier.

Tipos PT_BEZIERTO sempre ocorrem em conjuntos de três. A posição atual define o ponto de partida para o spline Bzier. Os dois primeiros pontos PT_BEZIERTO são os pontos de controle e o terceiro ponto PT_BEZIERTO é o ponto final. O ponto final se torna a nova posição atual. Se não houver três pontos consecutivos PT_BEZIERTO , um erro resulta.

Um tipo PT_LINETO ou PT_BEZIERTO pode ser combinado com a seguinte constante, usando o operador OR bit a bit, para indicar que o ponto correspondente é o último ponto em uma figura e que a figura está fechada:

  • PT_CLOSEFIGUREEspecifica que a figura é fechada automaticamente depois que o tipo PT_LINETO ou PT_BEZIERTO desse ponto é feito. Uma linha é desenhada desse ponto para o ponto mais recente PT_MOVETO ou MoveTo.

    Esse sinalizador é combinado com o tipo PT_LINETO de uma linha ou com o tipo PT_BEZIERTO de ponto final para um spline Bzier usando o operador OR bit a bit. A posição atual é definida como o ponto final da linha de fechamento.

nCount
Especifica o número total de pontos na matriz lpPoints, o mesmo que o número de bytes na matriz lpTypes.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função pode ser usada para desenhar figuras desarticuladas no lugar de chamadas consecutivas para funções de membro CDC::MoveTo, CDC::LineTo e CDC::PolyBezierTo. As linhas e splines são desenhadas usando a caneta atual e as figuras não são preenchidas. Se houver um caminho ativo iniciado chamando a CDC::BeginPath função de membro, PolyDraw adicionará ao caminho. Os pontos contidos na matriz lpPoints e em lpTypes indicam se cada ponto faz parte de uma operação CDC::MoveTo, CDC::LineTo ou CDC::BezierTo. Também é possível fechar números. Essa função atualiza a posição atual.

Exemplo

Confira o exemplo de CDC::BeginPath.

CDC::Polygon

Desenha um polígono que consiste em dois ou mais pontos (vértices) conectados por linhas usando a caneta atual.

BOOL Polygon(
    LPPOINT lpPoints,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de pontos que especifica os vértices do polígono. Cada ponto na matriz é uma estrutura POINT ou um objeto CPoint.

nCount
Especifica o número de vértices na matriz.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O sistema fecha o polígono automaticamente, se necessário, desenhando uma linha do último vértice ao primeiro.

O modo de preenchimento de polígono atual pode ser recuperado ou definido usando as funções de membro GetPolyFillMode e SetPolyFillMode.

Exemplo

void CDCView::DrawPolygon(CDC *pDC)
{
   // find the client area
   CRect rect;
   GetClientRect(rect);

   // draw with a thick blue pen
   CPen penBlue(PS_SOLID, 5, RGB(0, 0, 255));
   CPen *pOldPen = pDC->SelectObject(&penBlue);

   // and a solid red brush
   CBrush brushRed(RGB(255, 0, 0));
   CBrush *pOldBrush = pDC->SelectObject(&brushRed);

   // Find the midpoints of the top, right, left, and bottom
   // of the client area. They will be the vertices of our polygon.
   CPoint pts[4];
   pts[0].x = rect.left + rect.Width() / 2;
   pts[0].y = rect.top;

   pts[1].x = rect.right;
   pts[1].y = rect.top + rect.Height() / 2;

   pts[2].x = pts[0].x;
   pts[2].y = rect.bottom;

   pts[3].x = rect.left;
   pts[3].y = pts[1].y;

   // Calling Polygon() on that array will draw three lines
   // between the points, as well as an additional line to
   // close the shape--from the last point to the first point
   // we specified.
   pDC->Polygon(pts, 4);

   // Put back the old objects.
   pDC->SelectObject(pOldPen);
   pDC->SelectObject(pOldBrush);
}

CDC::Polyline

Desenha um conjunto de segmentos de linha que conectam os pontos especificados por lpPoints.

BOOL Polyline(
    LPPOINT lpPoints,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas POINT ou objetos CPoint que serão conectados.

nCount`
Especifica o número de pontos na matriz. Esse valor deve ser pelo menos 2.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

As linhas são desenhadas do primeiro ponto até os pontos subsequentes usando a caneta atual. Ao contrário da LineTo função de membro, a função não usa ou atualiza a Polyline posição atual.

Para obter mais informações, consulte PolyLine no SDK do Windows.

CDC::PolylineTo

Desenha uma ou mais linhas retas.

BOOL PolylineTo(
    const POINT* lpPoints,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas de dados POINT que contém os vértices da linha.

nCount
Especifica o número de pontos na matriz.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Uma linha é desenhada da posição atual para o primeiro ponto especificado pelo parâmetro lpPoints usando a caneta atual. Para cada linha adicional, a função extrai do ponto final da linha anterior para o próximo ponto especificado por lpPoints. PolylineTo move a posição atual para o ponto final da última linha. Se os segmentos de linha desenhados por essa função formarem uma figura fechada, a figura não será preenchida.

CDC::PolyPolygon

Cria dois ou mais polígonos que são preenchidos usando o modo de preenchimento de polígono atual.

BOOL PolyPolygon(
    LPPOINT lpPoints,
    LPINT lpPolyCounts,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas POINT ou objetos CPoint que define os vértices dos polígonos.

lpPolyCounts
Aponta para uma matriz de inteiros, cada um deles especifica o número de pontos em um dos polígonos na matriz lpPoints.

nCount
O número de entradas na matriz lpPolyCounts. Esse número especifica o número de polígonos a serem desenhados. Esse valor deve ser pelo menos 2.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Os polígonos podem ser desarticulados ou podem se sobrepor.

Cada polígono especificado em uma chamada para a função PolyPolygon deve ser fechado. Ao contrário dos Polygon polígonos criados pela função de membro, os polígonos criados por PolyPolygon não são fechados automaticamente.

A função cria dois ou mais polígonos. Para criar um único polígono, um aplicativo deve usar a função de membro Polygon.

O modo de preenchimento de polígono atual pode ser recuperado ou definido usando as funções de membro GetPolyFillMode e SetPolyFillMode.

CDC::PolyPolyline

Desenha várias séries de segmentos de linha conectados.

BOOL PolyPolyline(
    const POINT* lpPoints,
    const DWORD* lpPolyPoints,
    int nCount);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas que contém os vértices das polilinhas. As polilinhas são especificadas consecutivamente.

lpPolyPoints
Aponta para uma matriz de variáveis que especifica o número de pontos na matriz lpPoints para o polígono correspondente. Cada entrada precisa ser maior ou igual a 2.

nCount
Especifica o número total de contagens na matriz lpPolyPoints.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Os segmentos de linha são desenhados usando a caneta atual. Os números formados pelos segmentos não são preenchidos. A posição atual não é usada ou atualizada por esta função.

CDC::PtVisible

Determina se o ponto determinado está dentro da área de recorte do contexto do dispositivo.

virtual BOOL PtVisible(
    int x,
    int y) const;

BOOL PtVisible(POINT point) const;

Parâmetros

x
Especifica a coordenada x lógica do ponto.

y
Especifica a coordenada y lógica do ponto.

point
Especifica o ponto para verificar as coordenadas lógicas. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Diferente de zero se o ponto especificado estiver dentro da área de recorte; caso contrário, 0.

CDC::QueryAbort

Chama a função de anulação instalada pela função de membro SetAbortProc para um aplicativo de impressão e consulta se a impressão deve ser encerrada.

BOOL QueryAbort() const;

Valor de Devolução

O valor de retorno será diferente de zero se a impressão continuar ou se não houver nenhum procedimento de anulação. É 0 se o trabalho de impressão deve ser encerrado. O valor retornado é fornecido pela função de anulação.

CDC::RealizePalette

Mapeia as entradas da paleta lógica atual para a paleta do sistema.

UINT RealizePalette();

Valor de Devolução

Indica quantas entradas na paleta lógica foram mapeadas para entradas diferentes na paleta do sistema. Isso representa o número de entradas que essa função remapeou para acomodar alterações na paleta do sistema desde que a paleta lógica foi realizada pela última vez.

Comentários

Uma paleta de cores lógica atua como um buffer entre aplicativos com uso intensivo de cores e o sistema, permitindo que um aplicativo use quantas cores forem necessárias sem interferir em suas próprias cores exibidas ou com cores exibidas por outras janelas.

Quando uma janela tem o foco de entrada e as chamadas RealizePalette, o Windows garante que a janela exibirá todas as cores solicitadas, até o número máximo disponível simultaneamente na tela. O Windows também exibe cores não encontradas na paleta da janela, combinando-as com as cores disponíveis.

Além disso, o Windows corresponde às cores solicitadas por janelas inativas que chamam a função o mais próximo possível das cores disponíveis. Isso reduz significativamente as alterações indesejáveis nas cores exibidas em janelas inativas.

CDC::Rectangle

Desenha um retângulo usando a caneta atual.

BOOL Rectangle(
    int x1,
    int y1,
    int x2,
    int y2);

BOOL Rectangle(LPCRECT lpRect);

Parâmetros

x1
Especifica a coordenada x do canto esquerdo superior do retângulo (em unidades lógicas).

y1
Especifica a coordenada y do canto esquerdo superior do retângulo (em unidades lógicas).

x2
Especifica a coordenada x do canto direito inferior do retângulo (em unidades lógicas).

y2
Especifica a coordenada y do canto direito inferior do retângulo (em unidades lógicas).

lpRect
Especifica o retângulo em unidades lógicas. Você pode passar um objeto CRect ou um ponteiro para uma estrutura RECT para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O interior do retângulo é preenchido usando o pincel atual.

O retângulo se estende até, mas não inclui, as coordenadas direita e inferior. Isso significa que a altura do retângulo é y2 - y1 e a largura do retângulo é x2 - x1. A largura e a altura de um retângulo devem ser maiores que 2 unidades e menos de 32.767 unidades.

Exemplo

void CDCView::DrawRectangle(CDC *pDC)
{
   // create and select a solid blue brush
   CBrush brushBlue(RGB(0, 0, 255));
   CBrush *pOldBrush = pDC->SelectObject(&brushBlue);

   // create and select a thick, black pen
   CPen penBlack;
   penBlack.CreatePen(PS_SOLID, 3, RGB(0, 0, 0));
   CPen *pOldPen = pDC->SelectObject(&penBlack);

   // get our client rectangle
   CRect rect;
   GetClientRect(rect);

   // shrink our rect 20 pixels in each direction
   rect.DeflateRect(20, 20);

   // draw a thick black rectangle filled with blue
   pDC->Rectangle(rect);

   // put back the old objects
   pDC->SelectObject(pOldBrush);
   pDC->SelectObject(pOldPen);
}

CDC::RectVisible

Determina se alguma parte do retângulo determinado está dentro da área de recorte do contexto de execução de exibição.

virtual BOOL RectVisible(LPCRECT lpRect) const;

Parâmetros

lpRect
Aponta para uma estrutura RECT ou um objeto CRect que contém as coordenadas lógicas do retângulo especificado.

Valor de Devolução

Diferente de zero se qualquer parte do retângulo determinado estiver dentro da área de recorte; caso contrário, 0.

CDC::ReleaseAttribDC

Chame essa função de membro para definir m_hAttribDC como NULL.

virtual void ReleaseAttribDC();

Comentários

Isso não faz com que um Detach ocorra. Somente o contexto de dispositivo de saída é anexado ao objeto CDC, e somente ele pode ser desanexado.

CDC::ReleaseOutputDC

Chame essa função de membro para definir o membro m_hDC como NULL.

virtual void ReleaseOutputDC();

Comentários

Essa função de membro não pode ser chamada quando o contexto do dispositivo de saída é anexado ao objeto CDC. Use a função de membro Detach para desanexar o contexto do dispositivo de saída.

CDC::ResetDC

Chame essa função de membro para atualizar o contexto do dispositivo encapsulado pelo objeto CDC.

BOOL ResetDC(const DEVMODE* lpDevMode);

Parâmetros

lpDevMode
Um ponteiro para uma estrutura DEVMODE do Windows.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O contexto do dispositivo é atualizado a partir das informações especificadas na estrutura DEVMODE do Windows. Essa função de membro redefine apenas o contexto do dispositivo de atributo.

Um aplicativo normalmente usará a função de membro ResetDC quando uma janela processar uma mensagem WM_DEVMODECHANGE. Você também pode usar essa função de membro para alterar a orientação de papel ou os compartimentos de papel durante a impressão de um documento.

Você não pode usar essa função membro para alterar o nome do driver, o nome do dispositivo ou a porta de saída. Quando o usuário altera a conexão de porta ou o nome do dispositivo, você deve excluir o contexto original do dispositivo e criar um novo contexto de dispositivo com as novas informações.

Antes de chamar essa função de membro, você deve garantir que todos os objetos (além de objetos de estoque) selecionados no contexto do dispositivo tenham sido selecionados.

CDC::RestoreDC

Restaura o contexto do dispositivo para o estado anterior identificado por nSavedDC.

virtual BOOL RestoreDC(int nSavedDC);

Parâmetros

nSavedDC
Especifica o contexto de dispositivo a ser restaurado. Pode ser um valor retornado por uma chamada de função SaveDC anterior. Se nSavedDC for -1, o contexto do dispositivo salvo mais recentemente será restaurado.

Valor de Devolução

Diferente de zero se o contexto especificado foi restaurado; caso contrário, 0.

Comentários

RestoreDC restaura o contexto de dispositivo extraindo informações de estado de uma pilha criada por chamadas anteriores para a função de membro SaveDC.

A pilha pode conter as informações de estado para vários contextos de dispositivo. Se o contexto especificado por não estiver na parte superior da pilha, RestoreDC excluirá todas as informações de estado entre o contexto do dispositivo especificado por nSavedDCnSavedDC e a parte superior da pilha. As informações excluídas são perdidas.

CDC::RoundRect

Desenha um retângulo com cantos arredondados usando a caneta atual.

BOOL RoundRect(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3);

BOOL RoundRect(
    LPCRECT lpRect,
    POINT point);

Parâmetros

x1
Especifica a coordenada x do canto esquerdo superior do retângulo (em unidades lógicas).

y1
Especifica a coordenada y do canto esquerdo superior do retângulo (em unidades lógicas).

x2
Especifica a coordenada x do canto direito inferior do retângulo (em unidades lógicas).

y2
Especifica a coordenada y do canto direito inferior do retângulo (em unidades lógicas).

x3
Especifica a largura da elipse usada para desenhar os cantos arredondados (em unidades lógicas).

y3
Especifica a altura da elipse usada para desenhar os cantos arredondados (em unidades lógicas).

lpRect
Especifica o retângulo delimitador, em unidades lógicas. Você pode passar um objeto CRect ou um ponteiro para uma estrutura RECT para esse parâmetro.

point
A coordenada x de point especifica a largura da elipse para desenhar os cantos arredondados (em unidades lógicas). A coordenada y de point especifica a altura da elipse para desenhar os cantos arredondados (em unidades lógicas). Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O interior do retângulo é preenchido usando o pincel atual.

A figura desenhada por essa função se estende até, mas não inclui as coordenadas direita e inferior. Isso significa que a altura da figura é y2 - y1 e a largura da figura é x2 - x1. A altura e a largura do retângulo delimitador devem ser maiores que 2 unidades e menos de 32.767 unidades.

Exemplo

void CDCView::DrawRoundRect(CDC *pDC)
{
   // create and select a solid blue brush
   CBrush brushBlue(RGB(0, 0, 255));
   CBrush *pOldBrush = pDC->SelectObject(&brushBlue);

   // create and select a thick, black pen
   CPen penBlack;
   penBlack.CreatePen(PS_SOLID, 3, RGB(0, 0, 0));
   CPen *pOldPen = pDC->SelectObject(&penBlack);

   // get our client rectangle
   CRect rect;
   GetClientRect(rect);

   // shrink our rect 20 pixels in each direction
   rect.DeflateRect(20, 20);

   // Draw a thick black rectangle filled with blue
   // corners rounded at a 17-unit radius. Note that
   // a radius of three or less is not noticeable because
   // the pen is three units wide.
   pDC->RoundRect(rect, CPoint(17, 17));

   // put back the old objects
   pDC->SelectObject(pOldBrush);
   pDC->SelectObject(pOldPen);
}

CDC::SaveDC

Salva o estado atual do contexto do dispositivo copiando informações de estado (como região de recorte, objetos selecionados e modo de mapeamento) em uma pilha de contexto mantida pelo Windows.

virtual int SaveDC();

Valor de Devolução

Um inteiro que identifica o contexto do dispositivo salvo. É 0 se ocorrer um erro. Esse valor retornado pode ser usado para restaurar o contexto do dispositivo chamando RestoreDC.

Comentários

O contexto do dispositivo salvo pode ser restaurado posteriormente usando RestoreDC.

SaveDC pode ser usado várias vezes para salvar qualquer número de estados de contexto de dispositivo.

CDC::ScaleViewportExt

Modifica a extensão do visor em relação aos valores atuais.

virtual CSize ScaleViewportExt(
    int xNum,
    int xDenom,
    int yNum,
    int yDenom);

Parâmetros

xNum
Especifica a quantidade pela qual multiplicar a extensão x atual.

xDenom
Especifica a quantidade pela qual dividir o resultado da multiplicação da extensão x atual pelo valor do parâmetro xNum.

yNum
Especifica a quantidade pela qual a extensão de y atual deve ser multiplicada.

yDenom
Especifica a quantidade pela qual dividir o resultado da multiplicação da extensão y atual pelo valor do parâmetro yNum.

Valor de Devolução

As extensões de visor anteriores (em unidades de dispositivo) como um objeto CSize.

Comentários

As fórmulas são escritas da seguinte maneira:

xNewVE = ( xOldVE * xNum ) / xDenom

yNewVE = ( yOldVE * yNum ) / yDenom

As novas extensões do visor são calculadas multiplicando as extensões atuais pelo numerador determinado e, em seguida, dividindo pelo denominador determinado.

CDC::ScaleWindowExt

Modifica as extensões de janela relativas aos valores atuais.

virtual CSize ScaleWindowExt(
    int xNum,
    int xDenom,
    int yNum,
    int yDenom);

Parâmetros

xNum
Especifica a quantidade pela qual multiplicar a extensão x atual.

xDenom
Especifica a quantidade pela qual dividir o resultado da multiplicação da extensão x atual pelo valor do parâmetro xNum.

yNum
Especifica a quantidade pela qual a extensão de y atual deve ser multiplicada.

yDenom
Especifica a quantidade pela qual dividir o resultado da multiplicação da extensão y atual pelo valor do parâmetro yNum.

Valor de Devolução

As extensões de janela anteriores (em unidades lógicas) como um objeto CSize.

Comentários

As fórmulas são escritas da seguinte maneira:

xNewWE = ( xOldWE * xNum ) / xDenom

yNewWE = ( yOldWE * yNum ) / yDenom

As novas extensões de janela são calculadas multiplicando as extensões atuais pelo numerador determinado e, em seguida, dividindo pelo denominador determinado.

CDC::ScrollDC

Percorre um retângulo de bits horizontal e verticalmente.

BOOL ScrollDC(
    int dx,
    int dy,
    LPCRECT lpRectScroll,
    LPCRECT lpRectClip,
    CRgn* pRgnUpdate,
    LPRECT lpRectUpdate);

Parâmetros

dx
Especifica o número de unidades de rolagem horizontal.

dy
Especifica o número de unidades de rolagem vertical.

lpRectScroll
Aponta para a estrutura RECT ou objeto CRect que contém as coordenadas do retângulo de rolagem.

lpRectClip
Aponta para a estrutura RECT ou objeto CRect que contém as coordenadas do retângulo de recorte. Quando esse retângulo é menor que o original apontado por lpRectScroll, a rolagem ocorre apenas no retângulo menor.

pRgnUpdate
Identifica a região descoberta pelo processo de rolagem. A ScrollDC função define essa região, não é necessariamente um retângulo.

lpRectUpdate
Aponta para a estrutura RECT ou objeto CRect que recebe as coordenadas do retângulo que vincula a região de atualização de rolagem. Essa é a maior área retangular que requer repintura. Os valores na estrutura ou objeto quando a função retorna estão nas coordenadas do cliente, independentemente do modo de mapeamento para o contexto de dispositivo fornecido.

Valor de Devolução

Diferente de zero se a rolagem for executada; caso contrário, 0.

Comentários

Se lpRectUpdate for NULL, o Windows não computa o retângulo de atualização. Se ambos pRgnUpdate e lpRectUpdate forem NULL, o Windows não computará a região de atualização. Se pRgnUpdate não NULLestiver, o Windows assume que contém um ponteiro válido para a região descoberta pelo processo de rolagem (definido pela ScrollDC função de membro). A área de atualização retornada em lpRectUpdate pode ser passada para CWnd::InvalidateRgn se necessário.

Um aplicativo deve usar a função de membro da classe CWnd quando for necessário rolar toda a ScrollWindow área do cliente de uma janela. Caso contrário, ela deve usar ScrollDC.

CDC::SelectClipPath

Seleciona o caminho atual como uma área de recorte para o contexto do dispositivo, combinando a nova área com qualquer área de recorte existente usando o modo especificado.

BOOL SelectClipPath(int nMode);

Parâmetros

nMode
Especifica a maneira de usar o caminho. Os seguintes valores são permitidos:

  • RGN_AND A nova região de recorte inclui a interseção (áreas sobrepostas) da área de recorte atual e o caminho atual.

  • RGN_COPY A nova área de recorte é o caminho atual.

  • RGN_DIFF A nova área de recorte inclui as áreas da área de recorte atual, e as do caminho atual são excluídas.

  • RGN_OR A nova área de recorte inclui a união (áreas combinadas) a área de recorte atual e o caminho atual.

  • RGN_XOR A nova área de recorte inclui a união da área de recorte atual e o caminho atual, mas sem sobrepor áreas.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O contexto de dispositivo identificado deve conter um caminho fechado.

CDC::SelectClipRgn

Seleciona a região fornecida como a região de recorte atual para o contexto do dispositivo.

int SelectClipRgn(CRgn* pRgn);

int SelectClipRgn(
    CRgn* pRgn,
    int nMode);

Parâmetros

pRgn
Identifica a região que será selecionada.

  • Para a primeira versão dessa função, se esse valor for NULL, toda a área do cliente será selecionada e a saída ainda será recortada para a janela.

  • Para a segunda versão dessa função, esse identificador pode ser NULL somente quando o modo RGN_COPY é especificado.

nMode
Especifica a operação a ser executada. Deve ser um dos seguintes valores:

  • RGN_AND A nova área de recorte combina as áreas sobrepostas da região de recorte atual e a região identificada por pRgn.

  • RGN_COPY A nova área de recorte é uma cópia da região identificada por pRgn. Essa é a funcionalidade idêntica à primeira versão de SelectClipRgn. Se a região identificada por pRgn for NULL, a nova área de recorte se tornará a área de recorte padrão (uma região nula).

  • RGN_DIFF A nova área de recorte combina as áreas da área de recorte atual com as áreas excluídas da região identificada por pRgn.

  • RGN_OR A nova área de recorte combina a região de recorte atual e a região identificada por pRgn.

  • RGN_XOR A nova área de recorte combina aa área de recorte atual e a região identificada por pRgn, mas exclui qualquer área sobreposta.

Valor de Devolução

O tipo da região. Pode ser qualquer um dos seguintes valores:

  • COMPLEXREGION A nova área de recorte tem bordas sobrepostas.

  • ERROR O contexto ou a região do dispositivo não é válido.

  • NULLREGION A nova área de recorte está vazia.

  • SIMPLEREGION A nova área de recorte não tem bordas sobrepostas.

Comentários

Apenas uma cópia da região selecionada é usada. A região em si pode ser selecionada para qualquer número de outros contextos de dispositivo ou pode ser excluída.

A função pressupõe que as coordenadas da região determinada sejam especificadas em unidades de dispositivo. Alguns dispositivos de impressora dão suporte à saída de texto em uma resolução maior do que a saída gráfica, a fim de manter a precisão necessária para expressar as métricas de texto. Esses dispositivos relatam unidades de dispositivo na resolução mais alta, ou seja, em unidades de texto. Esses dispositivos dimensionam coordenadas para gráficos para que várias unidades de dispositivo relatadas mapeiem para apenas 1 unidade gráfica. Você sempre deve chamar a função SelectClipRgn usando unidades de texto.

Os aplicativos que devem usar o dimensionamento de objetos gráficos na GDI podem usar a escape de impressora GETSCALINGFACTOR para determinar o fator de escala. Esse fator de escala afeta o recorte. Se uma região for usada para recortar elementos gráficos, a GDI dividirá as coordenadas pelo fator de escala. Se a região for usada para cortar texto, a GDI não fará nenhum ajuste de escala. Um fator de dimensionamento de 1 faz com que as coordenadas sejam divididas por 2; um fator de escala de 2 faz com que as coordenadas sejam divididas por 4, e assim por diante.

CDC::SelectObject

Seleciona um objeto no contexto de dispositivo.

CPen* SelectObject(CPen* pPen);
CBrush* SelectObject(CBrush* pBrush);
virtual CFont* SelectObject(CFont* pFont);
CBitmap* SelectObject(CBitmap* pBitmap);
int SelectObject(CRgn* pRgn);
CGdiObject* SelectObject(CGdiObject* pObject);

Parâmetros

pPen
Um ponteiro para um objeto CPen que será selecionado.

pBrush
Um ponteiro para um objeto CBrush que será selecionado.

pFont
Um ponteiro para um objeto CFont que será selecionado.

pBitmap
Um ponteiro para um objeto CBitmap que será selecionado.

pRgn
Um ponteiro para um objeto CRgn que será selecionado.

pObject
Um ponteiro para um objeto CGdiObject que será selecionado.

Valor de Devolução

Um ponteiro para o objeto que está sendo substituído. Esse é um ponteiro para um objeto de uma das classes derivadas de CGdiObject, por exemplo, CPen, dependendo de qual versão da função é usada. O valor de retorno é NULL se houver um erro. Essa função pode retornar um ponteiro para um objeto temporário. Esse objeto temporário somente será válido durante o processamento de uma mensagem do Windows. Para obter mais informações, consulte CGdiObject::FromHandle.

A versão da função membro que usa um parâmetro de região executa a mesma tarefa que a função de membro SelectClipRgn. O valor retornado pode ser qualquer um dos seguintes:

  • COMPLEXREGION A nova área de recorte tem bordas sobrepostas.

  • ERROR O contexto ou a região do dispositivo não é válido.

  • NULLREGION A nova área de recorte está vazia.

  • SIMPLEREGION A nova área de recorte não tem bordas sobrepostas.

Comentários

A classe CDC fornece cinco versões especializadas para tipos específicos de objetos GDI, incluindo canetas, pincéis, fontes, bitmaps e regiões. O objeto recém-selecionado substitui o objeto anterior do mesmo tipo. Por exemplo, se pObject da versão geral de SelectObject apontar para um objeto CPen, a função substituirá a caneta atual pela caneta especificada por pObject.

Um aplicativo pode selecionar um bitmap somente em contextos de dispositivo de memória e em apenas um contexto de dispositivo de memória por vez. O formato do bitmap deve ser monocromático ou compatível com o contexto do dispositivo; se não estiver, SelectObject retorna um erro.

Para o Windows 3.1 e posterior, a SelectObject função retorna o mesmo valor se ele é usado em um metarquivo ou não. Em versões anteriores do Windows, SelectObject retornava um valor diferente de zero para êxito e 0 para falha quando ele era usado em um meta-arquivo.

CDC::SelectPalette

Seleciona a paleta lógica especificada por pPalette como o objeto de paleta selecionado do contexto do dispositivo.

CPalette* SelectPalette(
    CPalette* pPalette,
    BOOL bForceBackground);

Parâmetros

pPalette
Identifica a paleta lógica que será selecionada. Provavelmente, essa paleta já foi criada com CreatePalette da função de membro de CPalette.

bForceBackground
Especifica se a paleta lógica é forçada a ser uma paleta de planos de fundo. Se bForceBackground não for zero, a paleta selecionada sempre será uma paleta de planos de fundo, independentemente de a janela ter o foco de entrada. Se bForceBackground for 0 e o contexto do dispositivo estiver anexado a uma janela, a paleta lógica será uma paleta de primeiro plano quando a janela tiver o foco de entrada.

Valor de Devolução

Um ponteiro para um objeto CPalette que identifica a paleta lógica substituída pela paleta especificada por pPalette. É NULL se houver um erro.

Comentários

A nova paleta se torna o objeto de paleta usado pela GDI para controlar as cores exibidas no contexto do dispositivo e substitui a paleta anterior.

Um aplicativo pode selecionar uma paleta lógica em mais de um contexto de dispositivo. No entanto, as alterações em uma paleta lógica afetarão todos os contextos de dispositivo para os quais ela está selecionada. Se um aplicativo selecionar uma paleta em mais de um contexto de dispositivo, todos os contextos do dispositivo deverão pertencer ao mesmo dispositivo físico.

CDC::SelectStockObject

Seleciona um objeto CGdiObject que corresponde a uma das canetas, pincéis ou fontes fixos predefinidos.

virtual CGdiObject* SelectStockObject(int nIndex);

Parâmetros

nIndex
Especifica o tipo de objeto fixo desejado. Pode ser um dos seguintes valores:

  • BLACK_BRUSH Pincel preto.

  • DKGRAY_BRUSH Pincel cinza escuro.

  • GRAY_BRUSH Pincel cinza.

  • HOLLOW_BRUSH Pincel vazado.

  • LTGRAY_BRUSH Pincel cinza claro.

  • NULL_BRUSH Pincel nulo.

  • WHITE_BRUSH Pincel branco.

  • BLACK_PEN Caneta preta.

  • NULL_PEN Caneta nula.

  • WHITE_PEN Caneta branca.

  • ANSI_FIXED_FONT Fonte de sistema fixa ANSI.

  • ANSI_VAR_FONT Fonte do sistema variável ANSI.

  • DEVICE_DEFAULT_FONT Fonte dependente de dispositivo.

  • OEM_FIXED_FONT Fonte fixa dependente de OEM.

  • SYSTEM_FONT A fonte do sistema. Por padrão, o Windows usa a fonte do sistema para desenhar menus, controles de caixa de diálogo e outros textos. É melhor, no entanto, não confiar para SYSTEM_FONT obter a fonte usada por caixas de diálogo e janelas. Em vez disso, use a função SystemParametersInfo com o parâmetro SPI_GETNONCLIENTMETRICS para recuperar a fonte atual. SystemParametersInfo leva em conta o tema atual e fornece informações de fonte para legendas, menus e caixas de diálogo de mensagens.

  • SYSTEM_FIXED_FONT A fonte do sistema de largura fixa usada no Windows antes da versão 3.0. Esse objeto está disponível para compatibilidade com versões anteriores do Windows.

  • DEFAULT_PALETTE Paleta de cores padrão. Essa paleta consiste nas 20 cores estáticas na paleta do sistema.

Valor de Devolução

Um ponteiro para o objeto CGdiObject que foi substituído se a função for bem-sucedida. O objeto real apontado é um objeto CPen, CBrush ou CFont. Se a chamada não for bem-sucedida, o valor retornado será NULL.

CDC::SetAbortProc

Instala o procedimento de anulação do trabalho de impressão.

int SetAbortProc(BOOL (CALLBACK* lpfn)(HDC, int));

Parâmetros

lpfn
Um ponteiro para a função de anulação a ser instalada como o procedimento de anulação. Para obter mais informações sobre a função de retorno de chamada, consulte Função de retorno de chamada para CDC::SetAbortProc.

Valor de Devolução

Especifica o resultado da função SetAbortProc. Alguns dos valores a seguir são mais prováveis do que outros, mas todos são possíveis.

  • SP_ERROR Erro geral.

  • SP_OUTOFDISK No momento, não há espaço em disco suficiente disponível para spooling e não haverá mais espaço disponível.

  • SP_OUTOFMEMORY Não há memória suficiente disponível para spooling.

  • SP_USERABORT O usuário finalizou o trabalho por meio do Gerenciador de impressão.

Comentários

Se um aplicativo permitir que o trabalho de impressão seja cancelado durante o spool, ele deverá definir a função abortar antes que o trabalho de impressão seja iniciado com a função de membro StartDoc. O Gerenciador de impressão chama a função abortar durante o spool para permitir que o aplicativo cancele o trabalho de impressão ou processe condições fora do espaço em disco. Se nenhuma função de interrupção for definida, o trabalho de impressão falhará se não houver espaço em disco suficiente para o spool.

Os recursos do Microsoft Visual C++ simplificam a criação da função de retorno de chamada passada para SetAbortProc. O endereço passado para a função de membro EnumObjects é um ponteiro para uma função exportada com __declspec(dllexport) e com a convenção de chamada __stdcall.

Você também não precisa exportar o nome da função em uma EXPORTS instrução no arquivo de definição de módulo do aplicativo. Em vez disso, você pode usar o modificador de função EXPORT, como em

BOOL CALLBACK EXPORT AFunction( HDC, int );

para fazer com que o compilador emita o registro de exportação adequado para exportação por nome sem aliasing. Isso funciona para a maioria das necessidades. Para alguns casos especiais, como exportar uma função por ordinal ou aliasing da exportação, você ainda precisa usar uma instrução EXPORTS em um arquivo de definição de módulo.

As interfaces de registro de retorno de chamada agora são de tipo seguro (você deve passar um ponteiro de função que aponta para o tipo certo de função para o retorno de chamada específico).

Todas as funções de retorno de chamada devem interceptar exceções do Microsoft Foundation antes de retornar ao Windows, já que as exceções não podem ser lançadas além dos limites de retorno de chamada. Para mais informações sobre exceções, confira o artigo Exceções.

CDC::SetArcDirection

Define a direção do desenho a ser usada para funções de arco e retângulo.

int SetArcDirection(int nArcDirection);

Parâmetros

nArcDirection
Especifica a direção do novo arco. Esse parâmetro pode ser qualquer um dos seguintes valores:

  • AD_COUNTERCLOCKWISE Figuras desenhadas no sentido anti-horário.

  • AD_CLOCKWISE Figuras desenhadas no sentido horário.

Valor de Devolução

Especifica a direção do arco antigo, se bem-sucedido; caso contrário, 0.

Comentários

A direção padrão é no sentido anti-horário. A função SetArcDirection especifica a direção na qual as seguintes funções desenham:

Arc Pizza
ArcTo Rectangle
Chord RoundRect
Ellipse

CDC::SetAttribDC

Chame essa função para definir o contexto do dispositivo de atributo m_hAttribDC.

virtual void SetAttribDC(HDC hDC);

Parâmetros

hDC
O contexto de dispositivo Windows.

Comentários

Essa função de membro não anexa o contexto do dispositivo ao CDC objeto. Somente o contexto do dispositivo de saída é anexado a um objeto CDC.

CDC::SetBkColor

Define a cor da tela de fundo atual para a cor especificada.

virtual COLORREF SetBkColor(COLORREF crColor);

Parâmetros

crColor
Especifica a nova cor da tela de fundo.

Valor de Devolução

A cor anterior da tela de fundo como um valor de cor RGB. Se ocorrer um erro, o valor retornado será 0x80000000.

Comentários

Se o modo de fundo for OPAQUE, o sistema usará a cor da tela de fundo para preencher as lacunas em linhas estilizadas, as lacunas entre linhas eclodidas em pincéis e a tela de fundo em células de caracteres. O sistema também usa a cor da tela de fundo ao converter bitmaps entre contextos de dispositivo monocromático e de cor.

Se o dispositivo não puder exibir a cor especificada, o sistema definirá a cor da tela de fundo como a cor física mais próxima.

CDC::SetBkMode

Define o modo em segundo plano.

int SetBkMode(int nBkMode);

Parâmetros

nBkMode
Especifica o modo a ser definido. Esse parâmetro pode ser qualquer um dos seguintes valores:

  • OPAQUE A tela de fundo é preenchida com a cor da tela de fundo atual antes que o texto, o pincel ou a caneta sejam desenhados. Esse é o modo de tela de fundo padrão.

  • TRANSPARENT O plano de fundo não é alterado antes do desenho.

Valor de Devolução

O modo da tela de fundo anterior.

Comentários

O modo de plano de fundo define se o sistema remove as cores de plano de fundo existentes na superfície de desenho antes de desenhar texto, pincéis com hachura ou qualquer estilo de caneta que não seja uma linha sólida.

Exemplo

Confira o exemplo de CWnd::OnCtlColor.

CDC::SetBoundsRect

Controla o acúmulo de informações delimitador-retângulo para o contexto do dispositivo especificado.

UINT SetBoundsRect(
    LPCRECT lpRectBounds,
    UINT flags);

Parâmetros

lpRectBounds
Aponta para uma estrutura RECT ou objeto CRect usado para definir o retângulo delimitador. As dimensões do retângulo são fornecidas em coordenadas lógicas. Esse parâmetro pode ser NULL.

flags
Especifica como o novo retângulo será combinado com o retângulo acumulado. Esse parâmetro pode ser uma combinação dos seguintes valores:

  • DCB_ACCUMULATE Adicione o retângulo especificado pelo retângulo delimitador lpRectBounds (usando uma operação de união de retângulo).

  • DCB_DISABLE Desativar o acúmulo de limites.

  • DCB_ENABLE Ativar o acúmulo de limites. (A configuração padrão para o acúmulo de limites está desabilitada.)

Valor de Devolução

O estado atual do retângulo delimitador se a função for bem-sucedida. Assim como flags, o valor retornado pode ser uma combinação de valores DCB_:

  • DCB_ACCUMULATE O retângulo delimitador não está vazio. Esse valor sempre será definido.

  • DCB_DISABLE O acúmulo de limites está desativado.

  • DCB_ENABLE O acúmulo de limites está ativado.

Comentários

O Windows pode manter um retângulo delimitador para todas as operações de desenho. Esse retângulo pode ser consultado e redefinido pelo aplicativo. Os limites de desenho são úteis para invalidar caches de bitmap.

CDC::SetBrushOrg

Especifica a origem que a GDI atribuirá ao próximo pincel selecionado pelo aplicativo no contexto do dispositivo.

CPoint SetBrushOrg(
    int x,
    int y);

CPoint SetBrushOrg(POINT point);

Parâmetros

x
Especifica a coordenada x (em unidades de dispositivo) da nova origem. Esse valor deve estar entre 0 e 7.

y
Especifica a coordenada y (em unidades de dispositivo) da nova origem. Esse valor deve estar entre 0 e 7.

point
Especifica a coordenada x e y da nova origem. Cada valor deve estar entre 0 e 7. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

A origem anterior do pincel em unidades do dispositivo.

Comentários

As coordenadas padrão para a origem do pincel são (0, 0). Para alterar a origem de um pincel, chame a função UnrealizeObject para o objeto CBrush, chame SetBrushOrg e, em seguida, chame a função de membro SelectObject para selecionar o pincel no contexto do dispositivo.

Não use SetBrushOrg com objetos de estoque CBrush .

CDC::SetColorAdjustment

Define os valores de ajuste de cor para o contexto do dispositivo usando os valores especificados.

BOOL SetColorAdjustment(const COLORADJUSTMENT* lpColorAdjust);

Parâmetros

lpColorAdjust
Aponta para uma estrutura de dados COLORADJUSTMENT que contém os valores de ajuste de cor.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

Os valores de ajuste de cor são usados para ajustar a cor de entrada do bitmap de origem para chamadas à função membro CDC::StretchBlt quando o modo HALFTONE é definido.

CDC::SetDCBrushColor

Define a cor do pincel do contexto de dispositivo (DC) atual como o valor de cor especificado.

COLORREF SetDCBrushColor(COLORREF crColor);

Parâmetros

crColor
Especifica a nova cor do pincel.

Valor de Devolução

Se a função for bem-sucedida, o valor retornado especifica a cor anterior do pincel DC como um valor COLORREF.

Se a função falhar, o valor retornado será CLR_INVALID.

Comentários

Essa função de membro emula a funcionalidade da função SetDCBrushColor, conforme descrito no SDK do Windows.

CDC::SetDCPenColor

Define a cor da caneta de contexto de dispositivo (DC) atual como o valor de cor especificado.

COLORREF SetDCPenColor(COLORREF crColor);

Parâmetros

crColor
Especifica a nova cor da caneta.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função de membro utiliza a função do Win32 SetDCPenColor, conforme descrito no SDK do Windows.

CDC::SetGraphicsMode

Define o modo gráfico atual para o contexto do dispositivo especificado.

int SetGraphicsMode(int iMode);

Parâmetros

iMode
Especifica o modo gráfico. Para obter uma lista dos valores que esse parâmetro pode usar, consulte SetGraphicsMode.

Valor de Devolução

Retorna o modo gráfico antigo com êxito.

Retorna 0 em caso de falha. Para obter outras informações sobre o erro, chame GetLastError.

Comentários

Esse método encapsula a função GDI do Windows SetGraphicsMode.

CDC::SetLayout

Chame essa função de membro para alterar o layout do texto e dos elementos gráficos de um contexto de dispositivo da direita para a esquerda, o layout padrão para culturas como árabe e hebraico.

DWORD SetLayout(DWORD dwLayout);

Parâmetros

dwLayout
Layout de contexto do dispositivo e sinalizadores de controle de bitmap. Pode ser uma combinação dos seguintes valores.

Valor Significado
LAYOUT_BITMAPORIENTATIONPRESERVED Desabilita qualquer reflexão de chamadas para CDC::BitBlt e CDC::StretchBlt.
LAYOUT_RTL Define o layout horizontal padrão para ser da direita para a esquerda.
LAYOUT_LTR Define o layout padrão para ser da esquerda para a direita.

Valor de Devolução

Se tiver êxito, o layout anterior do contexto de dispositivo.

Se não tiver êxito, GDI_ERROR. Para obter outras informações sobre o erro, chame GetLastError.

Comentários

Normalmente, você não chamaria SetLayout para uma janela. Em vez disso, você controla o layout da direita para a esquerda em uma janela definindo os estilos de janela estendida, como WS_EX_RTLREADING. Um contexto de dispositivo, como uma impressora ou um metarquivo, não herda esse layout. A única maneira de definir o contexto do dispositivo para um layout da direita para a esquerda é chamando SetLayout.

Se você chamar SetLayout(LAYOUT_RTL), SetLayout alterará automaticamente o modo de mapeamento para MM_ISOTROPIC. Como resultado, uma chamada subsequente para GetMapMode retornará MM_ISOTROPIC em vez de MM_TEXT.

Em alguns casos, como com muitos bitmaps, talvez você queira preservar o layout da esquerda para a direita. Nesses casos, renderize a imagem chamando BitBlt ou StretchBlt, em seguida, defina o sinalizador de controle bitmap de dwLayout como LAYOUT_BITMAPORIENTATIONPRESERVED.

Depois de alterar o layout com o sinalizador LAYOUT_RTL, os sinalizadores que normalmente especificam direita ou esquerda são invertidos. Para evitar confusão, convém definir nomes alternativos para os sinalizadores padrão. Para obter uma lista de nomes de sinalizadores alternativos sugeridos, consulte SetLayout no SDK do Windows.

CDC::SetMapMode

Define o modo de mapeamento.

virtual int SetMapMode(int nMapMode);

Parâmetros

nMapMode
Especifica o novo modo de mapeamento. Pode ser qualquer um dos seguintes valores:

  • MM_ANISOTROPIC Unidades lógicas são convertidas em unidades arbitrárias com eixos arbitrariamente dimensionados. Definir o modo de mapeamento como MM_ANISOTROPIC não altera as configurações atuais da janela ou do visor. Para alterar as unidades, a orientação e a escala, chame as funções de membro SetWindowExte SetViewportExt.

  • MM_HIENGLISH Cada unidade lógica é convertida em 0,001 polegada. O x positivo fica à direita; o y positivo fica para cima.

  • MM_HIMETRIC Cada unidade lógica é convertida em 0,01 milímetro. O x positivo fica à direita; o y positivo fica para cima.

  • MM_ISOTROPIC As unidades lógicas são convertidas em unidades arbitrárias com eixos igualmente dimensionados; ou seja, 1 unidade ao longo do eixo x é igual a 1 unidade ao longo do eixo y. Use as funções de membro SetWindowExt e SetViewportExt para especificar as unidades desejadas e a orientação dos eixos. A GDI faz ajustes conforme necessário para garantir que as unidades x e y permaneçam do mesmo tamanho.

  • MM_LOENGLISH Cada unidade lógica é convertida em 0,01 polegada. O x positivo fica à direita; o y positivo fica para cima.

  • MM_LOMETRIC Cada unidade lógica é convertida em 0,1 milímetro. O x positivo fica à direita; o y positivo fica para cima.

  • MM_TEXT Cada unidade lógica é convertida em 1 pixel de dispositivo. O x positivo fica à direita; o y positivo fica para baixo.

  • MM_TWIPS Cada unidade lógica é convertida em 1/20 de um ponto. (Como um ponto é de 1/72 polegada, um twip é de 1/1440 polegadas.) O X positivo fica à direita; o y positivo fica para cima.

Valor de Devolução

O modo de mapeamento anterior.

Comentários

O modo de mapeamento define a unidade de medida usada para converter unidades lógicas em unidades de dispositivo; também define a orientação dos eixos x e y do dispositivo. A GDI usa o modo de mapeamento para converter coordenadas lógicas nas coordenadas de dispositivo apropriadas. O modo MM_TEXT permite que os aplicativos funcionem em pixels de dispositivo, em que 1 unidade é igual a 1 pixel. O tamanho físico de um pixel varia de dispositivo para dispositivo.

Os modos MM_HIENGLISH, MM_HIMETRIC, MM_LOENGLISH, MM_LOMETRIC e MM_TWIPSsão úteis para aplicativos que devem desenhar em unidades fisicamente significativas (como polegadas ou milímetros). O MM_ISOTROPIC modo garante uma proporção de 1:1, o que é útil quando é importante preservar a forma exata de uma imagem. O modo MM_ANISOTROPIC permite que as coordenadas x e y sejam ajustadas independentemente.

Observação

Se você chamar SetLayout para alterar o DC (contexto de dispositivo) para o layout da direita para a esquerda, SetLayout alterará automaticamente o modo de mapeamento para MM_ISOTROPIC.

Exemplo

Confira o exemplo de CView::OnPrepareDC.

CDC::SetMapperFlags

Altera o método usado pelo mapeador de fontes quando converte uma fonte lógica em uma fonte física.

DWORD SetMapperFlags(DWORD dwFlag);

Parâmetros

dwFlag
Especifica se o mapeador de fonte tenta corresponder à altura e à largura de uma fonte ao dispositivo. Quando esse valor é ASPECT_FILTERING, o mapeador seleciona apenas fontes cujo aspecto x e y correspondem exatamente às do dispositivo especificado.

Valor de Devolução

O valor anterior do sinalizador mapeador de fontes.

Comentários

Um aplicativo pode usar SetMapperFlags para fazer com que o mapeador de fontes tente escolher apenas uma fonte física que corresponda exatamente à taxa de proporção do dispositivo especificado.

Um aplicativo que usa apenas fontes raster pode usar a função SetMapperFlags para garantir que a fonte selecionada pelo mapeador de fontes seja atraente e legível no dispositivo especificado. Os aplicativos que usam fontes escalonáveis (TrueType) normalmente não usam SetMapperFlagso .

Se nenhuma fonte física tiver uma taxa de proporção que corresponda à especificação na fonte lógica, a GDI escolherá uma nova taxa de proporção e selecionará uma fonte que corresponda a essa nova taxa de proporção.

CDC::SetMiterLimit

Define o limite para o comprimento das junções de malhete para o contexto de dispositivo.

BOOL SetMiterLimit(float fMiterLimit);

Parâmetros

fMiterLimit
Especifica o novo limite do malhete para o contexto do dispositivo.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O comprimento do malhete é definido como a distância da interseção das paredes de linha no interior da junção ao cruzamento das paredes de linha do lado de fora da junção. O limite do malhete é a taxa máxima permitida do comprimento do malhete para a largura da linha. O limite padrão do malhete é 10.0.

CDC::SetOutputDC

Chame essa função de membro para definir m_hDC, o contexto de dispositivo de saída.

virtual void SetOutputDC(HDC hDC);

Parâmetros

hDC
O contexto de dispositivo Windows.

Comentários

Essa função de membro só pode ser chamada quando um contexto de dispositivo não foi anexado ao objeto CDC. Essa função de membro define m_hDC , mas não anexa o contexto do dispositivo ao CDC objeto.

CDC::SetPixel

Define o pixel no ponto especificado como a aproximação mais próxima da cor especificada por crColor.

COLORREF SetPixel(
    int x,
    int y,
    COLORREF crColor);

COLORREF SetPixel(
    POINT point,
    COLORREF crColor);

Parâmetros

x
Especifica a coordenada x lógica do ponto que será definido.

y
Especifica a coordenada y lógica do ponto que será testado.

crColor
Um valor RGB COLORREF que especifica a cor usada para pintar o ponto. Confira COLORREF no SDK do Windows uma descrição desse valor.

point
Especifica as coordenadas lógicas x e y do ponto a ser definido. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Um valor RGB para a cor que o ponto é pintado. Esse valor pode ser diferente daquele especificado por crColor de uma aproximação dessa cor for usada. Se a função falhar (se o ponto estiver fora da área de recorte), o valor retornado será -1.

Comentários

O ponto deve estar na área de recorte. Se o ponto não estiver na região de recorte, a função não fará nada.

Nem todos os dispositivos oferecem suporte à função SetPixel. Para determinar se um dispositivo oferece suporte a SetPixel, chame a função de membro GetDeviceCaps com o índice RASTERCAPS e verifique o valor de retorno para o sinalizador RC_BITBLT.

CDC::SetPixelV

Define o pixel nas coordenadas especificadas como a aproximação mais próxima da cor especificada.

BOOL SetPixelV(
    int x,
    int y,
    COLORREF crColor);

BOOL SetPixelV(
    POINT point,
    COLORREF crColor);

Parâmetros

x
Especifica a coordenada x, em unidades lógicas, do ponto a ser definido.

y
Especifica a coordenada y, em unidades lógicas, do ponto a ser definido.

crColor
Especifica a cor a ser usada para pintar o ponto.

point
Especifica as coordenadas lógicas x e y do ponto a ser definido. Você pode passar uma estrutura de dados POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O ponto deve estar na área de recorte e na parte visível da superfície do dispositivo. Nem todos os dispositivos oferecem suporte à função de membro . Para obter mais informações, consulte a funcionalidade RC_BITBLT na função de membro CDC::GetDeviceCaps. SetPixelV é mais rápido do que SetPixel porque não precisa retornar o valor de cor do ponto pintado.

CDC::SetPolyFillMode

Define o modo de preenchimento de polígono.

int SetPolyFillMode(int nPolyFillMode);

Parâmetros

nPolyFillMode
Especifica o novo modo de preenchimento. Esse valor pode ser ALTERNATE ou WINDING. O modo padrão definido no Windows é ALTERNATE.

Valor de Devolução

O modo de preenchimento anterior, se bem-sucedido; caso contrário, 0.

Comentários

Quando o modo de preenchimento de polígono é ALTERNATE, o sistema preenche a área entre lados de com numeração ímpar e numeração par do polígono em cada linha de verificação. Ou seja, o sistema preenche a área entre o primeiro e o segundo lados, entre o terceiro e o quarto lados e assim por diante. Esse modo é o padrão.

Quando o modo de preenchimento de polígono é WINDING, o sistema usa a direção na qual uma figura foi desenhada para determinar se uma área deve ser preenchida. Cada segmento de linha em um polígono é desenhado no sentido horário ou no sentido anti-horário. Sempre que uma linha imaginária desenhada de uma área fechada para o lado de fora de uma figura passa por um segmento de linha no sentido horário, a contagem é incrementada. Quando a linha passa por um segmento de linha no sentido anti-horário, a contagem é reduzida. A área será preenchida se a contagem for diferente de zero quando a linha atingir o exterior da figura.

CDC::SetROP2

Define o modo de desenho atual.

int SetROP2(int nDrawMode);

Parâmetros

nDrawMode
Especifica o novo modo de desenho. Pode ser qualquer um dos seguintes valores:

  • R2_BLACK O pixel é sempre preto.

  • R2_WHITE O pixel é sempre branco.

  • R2_NOP O pixel permanece inalterado.

  • R2_NOT O pixel é o inverso da cor da tela.

  • R2_COPYPEN O pixel é da cor da caneta.

  • R2_NOTCOPYPEN O pixel é o inverso da cor da caneta.

  • R2_MERGEPENNOT O pixel é uma combinação da cor da caneta e do inverso da cor da tela (pixel final = (~ pixel de tela) caneta |).

  • R2_MASKPENNOT O pixel é uma combinação das cores em comum entre a caneta e o inverso da tela (pixel final = (~ pixel de tela) caneta &).

  • R2_MERGENOTPEN O pixel é uma combinação da cor da tela e do inverso da cor da caneta (pixel final = (~ caneta) pixel da tela |).

  • R2_MASKNOTPEN O pixel é uma combinação das cores em comum entre a tela e o inverso da caneta (pixel final = (~ caneta) pixel da tela &).

  • R2_MERGEPEN O pixel é uma combinação da cor da caneta e da cor da tela (pixel final = pixel da tela | caneta).

  • R2_NOTMERGEPEN O pixel é o inverso da cor R2_MERGEPEN (pixel final = ~ (pixel da tela | da caneta)).

  • R2_MASKPEN O pixel é uma combinação das cores em comum entre a caneta e a tela (pixel final = pixel da tela & da caneta).

  • R2_NOTMASKPEN O pixel é o inverso da cor R2_MASKPEN (pixel final = ~ (pixel da tela & da caneta)).

  • R2_XORPEN O pixel é uma combinação das cores que estão na caneta ou na tela, mas não em ambas (pixel final = pixel de tela ^ da caneta).

  • R2_NOTXORPEN O pixel é o inverso da cor R2_XORPEN (pixel final = ~ (pixel da tela ^ da caneta)).

Valor de Devolução

O modo de desenho anterior.

Pode ser qualquer um dos valores fornecidos no SDK do Windows.

Comentários

O modo de desenho especifica como as cores da caneta e o interior dos objetos preenchidos são combinados com a cor já na superfície de exibição.

O modo de desenho é apenas para dispositivos raster; ele não se aplica a dispositivos vetoriais. Os modos de desenho são códigos de operação de raster binários que representam todas as combinações boolianas possíveis de duas variáveis, usando os operadores binários &, | e ^ (exclusivo |) e a operação unária ~.

CDC::SetStretchBltMode

Define o modo de alongamento de bitmap para a função de membro StretchBlt.

int SetStretchBltMode(int nStretchMode);

Parâmetros

nStretchMode
Especifica o modo de alongamento. Pode ser qualquer um dos seguintes valores:

Valor Descrição
BLACKONWHITE Executa uma operação booliana & usando os valores de cor para os pixels eliminados e existentes. Se o bitmap for um bitmap monocromático, esse modo preservará pixels pretos em detrimento de pixels brancos.
COLORONCOLOR Exclui os pixels. Esse modo exclui todas as linhas de pixels eliminadas sem tentar preservar suas informações.
HALFTONE Mapeia pixels do retângulo de origem em blocos de pixels no retângulo de destino. A cor média sobre o bloco de destino de pixels aproxima a cor dos pixels de origem.
Depois de definir o modo de alongamento HALFTONE, um aplicativo deve chamar a função Win32 SetBrushOrgEx para definir a origem do pincel. Se ele não fizer isso, ocorrerá desalinhamento de pincel.
STRETCH_ANDSCANS Windows 95/98: o mesmo que BLACKONWHITE
STRETCH_DELETESCANS Windows 95/98: o mesmo que COLORONCOLOR
STRETCH_HALFTONE Windows 95/98: o mesmo que HALFTONE
STRETCH_ORSCANS Windows 95/98: o mesmo que WHITEONBLACK
WHITEONBLACK Executa uma operação booliana | usando os valores de cor para os pixels eliminados e existentes. Se o bitmap for um bitmap monocromático, esse modo preservará pixels brancos em detrimento de pixels pretos.

Valor de Devolução

O modo de alongamento anterior. Pode ser STRETCH_ANDSCANS, STRETCH_DELETESCANS ou STRETCH_ORSCANS.

Comentários

O modo de alongamento de bitmap define como as informações são removidas dos bitmaps que são compactados pelo uso da função.

Normalmente, os modos BLACKONWHITE(STRETCH_ANDSCANS) e WHITEONBLACK(STRETCH_ORSCANS) são usados para preservar pixels em primeiro plano em bitmaps monocromáticos. Normalmente, o modo COLORONCOLOR(STRETCH_DELETESCANS) é usado para preservar a cor em bitmaps de cor.

O HALFTONE modo requer mais processamento da imagem de origem do que os outros três modos, é mais lento do que os outros, mas produz imagens de maior qualidade. Além disso, SetBrushOrgEx deve ser chamado após a configuração do modo para evitar o desalinhamento do HALFTONE pincel.

Mais modos de alongamento também podem estar disponíveis, dependendo dos recursos do driver de dispositivo.

CDC::SetTextAlign

Define os sinalizadores de alinhamento de texto.

UINT SetTextAlign(UINT nFlags);

Parâmetros

nFlags
Especifica sinalizadores de alinhamento de texto. Os sinalizadores especificam a relação entre um ponto e um retângulo que vincula o texto. O ponto pode ser a posição atual ou coordenadas especificadas por uma função de saída de texto. O retângulo que vincula o texto é definido pelas células de caractere adjacentes na cadeia de caracteres de texto. O parâmetronFlags pode ser um ou mais sinalizadores das três categorias a seguir. Escolha apenas um sinalizador de cada categoria. A primeira categoria afeta o alinhamento de texto na direção x:

  • TA_CENTER Alinha o ponto com o centro horizontal do retângulo delimitador.

  • TA_LEFT Alinha o ponto com o lado esquerdo do retângulo delimitador. Esta é a configuração padrão.

  • TA_RIGHT Alinha o ponto com o lado direito do retângulo delimitador.

A primeira categoria afeta o alinhamento de texto na direção y:

  • TA_BASELINE Alinha o ponto com a linha base da fonte escolhida.

  • TA_BOTTOM Alinha o ponto com a parte inferior do retângulo delimitador.

  • TA_TOP Alinha o ponto com a parte superior do retângulo delimitador. Esta é a configuração padrão.

A terceira categoria determina se a posição atual é atualizada quando o texto é gravado:

  • TA_NOUPDATECP Não atualiza a posição atual após cada chamada para uma função de saída de texto. Esta é a configuração padrão.

  • TA_UPDATECP Atualiza a posição atual após cada chamada para uma função de saída de texto. A nova posição está no lado direito do retângulo delimitador para o texto. Quando esse sinalizador é definido, as coordenadas especificadas em chamadas para a função de membro TextOut são ignoradas.

Valor de Devolução

A configuração de alinhamento de texto anterior, se for bem-sucedida. O byte de baixa ordem contém a configuração horizontal e o byte de alta ordem contém a configuração vertical; caso contrário, 0.

Comentários

As funções de membro TextOut e ExtTextOut usam esses sinalizadores ao posicionar uma cadeia de caracteres de texto em uma exibição ou dispositivo. Os sinalizadores especificam a relação entre um ponto específico e um retângulo que vincula o texto. As coordenadas desse ponto são passadas como parâmetros para a função de membro TextOut. O retângulo que vincula o texto é formado pelas células de caracteres adjacentes na cadeia de caracteres de texto.

CDC::SetTextCharacterExtra

Define a quantidade de espaçamento entre caracteres.

int SetTextCharacterExtra(int nCharExtra);

Parâmetros

nCharExtra
Especifica a quantidade de espaço extra (em unidades lógicas) a ser adicionada a cada caractere. Se o modo de mapeamento atual não MM_TEXTfor , nCharExtra será transformado e arredondado para o pixel mais próximo.

Valor de Devolução

A quantidade do espaçamento anterior entre caracteres.

Comentários

O GDI adiciona esse espaçamento a cada caractere, incluindo caracteres de interrupção, quando grava uma linha de texto no contexto do dispositivo. O valor padrão da quantidade de espaçamento entre caracteres é 0.

CDC::SetTextColor

Define a cor do texto como a cor especificada.

virtual COLORREF SetTextColor(COLORREF crColor);

Parâmetros

crColor
Especifica a cor do texto como um valor de cor RGB.

Valor de Devolução

Um valor RGB para a cor do texto anterior.

Comentários

O sistema usa essa cor de texto ao gravar texto nesse contexto de dispositivo e também ao converter bitmaps entre contextos de dispositivo colorido e monocromático.

Se o dispositivo não puder representar a cor especificada, o sistema definirá a cor do texto como a cor física mais próxima. A cor da tela de fundo de um caractere é especificada pelas funções de membroSetBkColor e SetBkMode.

Exemplo

Confira o exemplo de CWnd::OnCtlColor.

CDC::SetTextJustification

Adiciona espaço aos caracteres de quebra em uma cadeia de caracteres.

int SetTextJustification(
    int nBreakExtra,
    int nBreakCount);

Parâmetros

nBreakExtra
Especifica o espaço extra total a ser adicionado à linha de texto (em unidades lógicas). Se o modo de mapeamento atual não MM_TEXTfor , o valor fornecido por esse parâmetro será convertido para o modo de mapeamento atual e arredondado para a unidade de dispositivo mais próxima.

nBreakCount
Especifica o número de caracteres de quebra na linha.

Valor de Devolução

Será 1 se a função for bem-sucedida; caso contrário, 0.

Comentários

Um aplicativo pode usar as funções de membro GetTextMetrics para recuperar o caractere de quebra de uma fonte.

Depois que a função de membro SetTextJustification é chamada, uma chamada para uma função de saída de texto (como TextOut) distribui o espaço extra especificado uniformemente entre o número especificado de caracteres de interrupção. Normalmente, o caractere de quebra é o caractere de espaço (ASCII 32), mas pode ser definido por uma fonte como algum outro caractere.

Normalmente, a função de membro GetTextExtent é usada com SetTextJustification. GetTextExtent calcula a largura de uma determinada linha antes do alinhamento. Um aplicativo pode determinar quanto espaço especificar no parâmetro nBreakExtra subtraindo o valor retornado por GetTextExtent da largura da cadeia de caracteres após o alinhamento.

A função SetTextJustification pode ser usada para alinhar uma linha que contém várias execuções em fontes diferentes. Nesse caso, a linha deve ser criada em pedaços alinhando e escrevendo cada execução separadamente.

Como erros de arredondamento podem ocorrer durante o alinhamento, o sistema mantém um termo de erro em execução que define o erro atual. Ao alinhar uma linha que contém várias execuções, GetTextExtent usa automaticamente esse termo de erro quando calcula a extensão da próxima execução. Isso permite que a função de saída de texto misture o erro na nova execução.

Depois que cada linha tiver sido alinhada, esse termo de erro deve ser limpo para evitar que ela seja incorporada à próxima linha. O termo pode ser limpo chamando SetTextJustification com nBreakExtra definido como 0.

CDC::SetViewportExt

Define as extensões x e y do visor de contexto de dispositivo.

virtual CSize SetViewportExt(
    int cx,
    int cy);

CSize SetViewportExt(SIZE size);

Parâmetros

cx
Especifica a extensão x do visor (em unidades de dispositivo).

cy
Especifica a extensão y do visor (em unidades de dispositivo).

size
Especifica as extensões x e y do visor (em unidades de dispositivo).

Valor de Devolução

As extensões anteriores do visor como um objeto CSize. Quando ocorre um erro, as coordenadas x e y do objeto CSize retornado são definidas como 0.

Comentários

O visor, juntamente com a janela de contexto do dispositivo, define como a GDI mapeia pontos no sistema de coordenadas lógicas para pontos no sistema de coordenadas do dispositivo real. Em outras palavras, eles definem como a GDI converte coordenadas lógicas em coordenadas do dispositivo.

Quando os seguintes modos de mapeamento são definidos, chamadas para SetWindowExt e SetViewportExt são ignoradas:

MM_HIENGLISH MM_LOMETRIC
MM_HIMETRIC MM_TEXT
MM_LOENGLISH MM_TWIPS

Quando o modo MM_ISOTROPIC é definido, um aplicativo deve chamar a função de membro SetWindowExt antes de chamar SetViewportExt.

Exemplo

Confira o exemplo de CView::OnPrepareDC.

CDC::SetViewportOrg

Define a origem do visor do contexto do dispositivo.

virtual CPoint SetViewportOrg(
    int x,
    int y);

CPoint SetViewportOrg(POINT point);

Parâmetros

x
Especifica a coordenada x (em unidades de dispositivo) da origem do visor. O valor deve estar dentro do intervalo do sistema de coordenadas do dispositivo.

y
Especifica a coordenada y (em unidades de dispositivo) da origem do visor. O valor deve estar dentro do intervalo do sistema de coordenadas do dispositivo.

point
Especifica a origem do visor. Os valores deve estar dentro do intervalo do sistema de coordenadas do dispositivo. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

A origem anterior do visor (nas coordenadas do dispositivo) como um objeto CPoint.

Comentários

O visor, juntamente com a janela de contexto do dispositivo, define como a GDI mapeia pontos no sistema de coordenadas lógicas para pontos no sistema de coordenadas do dispositivo real. Em outras palavras, eles definem como a GDI converte coordenadas lógicas em coordenadas do dispositivo.

A origem do visor marca o ponto no sistema de coordenadas do dispositivo para o qual a GDI mapeia a origem da janela, um ponto no sistema de coordenadas lógica especificado pela função de membro SetWindowOrg. A GDI mapeia todos os outros pontos seguindo o mesmo processo necessário para mapear a origem da janela para a origem do visor. Por exemplo, todos os pontos em um círculo ao redor do ponto na origem da janela estarão em um círculo ao redor do ponto na origem do visor. Da mesma forma, todos os pontos em uma linha que passa pela origem da janela estarão em uma linha que passa pela origem do visor.

Exemplo

Confira o exemplo de CView::OnPrepareDC.

CDC::SetWindowExt

Define as extensões x e y da janela associada ao contexto de dispositivo.

virtual CSize SetWindowExt(
    int cx,
    int cy);

CSize SetWindowExt(SIZE size);

Parâmetros

cx
Especifica a extensão x (em unidades lógicas) da janela.

cy
Especifica a extensão y (em unidades lógicas) da janela.

size
Especifica as extensões x e y (em unidades lógicas) da janela.

Valor de Devolução

As extensões anteriores da janela (em unidades lógicas) como um objeto CSize. Se ocorrer um erro, as coordenadas x e y do objeto CSize retornado serão definidas como 0.

Comentários

A janela, juntamente com o visor de contexto de dispositivo, define como a GDI mapeia pontos no sistema de coordenadas lógicas para pontos no sistema de coordenadas de dispositivo.

Quando os seguintes modos de mapeamento são definidos, chamadas para as funções SetWindowExt e SetViewportExt são ignoradas:

  • MM_HIENGLISH

  • MM_HIMETRIC

  • MM_LOENGLISH

  • MM_LOMETRIC

  • MM_TEXT

  • MM_TWIPS

Quando o modo MM_ISOTROPIC é definido, um aplicativo deve chamar a função de membro SetWindowExt antes de chamar SetViewportExt.

Exemplo

Confira o exemplo de CView::OnPrepareDC.

CDC::SetWindowOrg

Define a origem da janela do contexto do dispositivo.

CPoint SetWindowOrg(
    int x,
    int y);

CPoint SetWindowOrg(POINT point);

Parâmetros

x
Especifica a coordenada x lógica da nova origem da janela.

y
Especifica a coordenada y lógica da nova origem da janela.

point
Especifica as coordenadas lógicas da nova origem da janela. Você pode passar uma estrutura POINT ou um objeto CPoint para esse parâmetro.

Valor de Devolução

A origem anterior da janela como um objeto CPoint.

Comentários

A janela, juntamente com o visor de contexto de dispositivo, define como a GDI mapeia pontos no sistema de coordenadas lógicas para pontos no sistema de coordenadas de dispositivo.

A origem da janela marca o ponto no sistema de coordenadas lógicas a partir do qual a GDI mapeia a origem do visor, um ponto no sistema de coordenadas de dispositivo especificado pela função SetWindowOrg. A GDI mapeia todos os outros pontos seguindo o mesmo processo necessário para mapear a origem da janela para a origem do visor. Por exemplo, todos os pontos em um círculo ao redor do ponto na origem da janela estarão em um círculo ao redor do ponto na origem do visor. Da mesma forma, todos os pontos em uma linha que passa pela origem da janela estarão em uma linha que passa pela origem do visor.

CDC::SetWorldTransform

Define uma transformação linear bidimensional entre espaço global e espaço de página para o contexto de dispositivo especificado. Essa transformação pode ser usada para dimensionar, girar, distorcer ou traduzir a saída de elementos gráficos.

BOOL SetWorldTransform(const XFORM& rXform);

Parâmetros

rXform
Referência a uma estrutura XFORM que contém os dados de transformação.

Valor de Devolução

Retorna um valor diferente de zero se tiver êxito.

Retorna 0 em caso de falha.

Para obter outras informações sobre o erro, chame GetLastError.

Comentários

Esse método encapsula a função GDI do Windows SetWorldTransform.

CDC::StartDoc

Informa ao driver do dispositivo que um novo trabalho de impressão está começando e que todas as chamadas StartPage e EndPage subsequentes devem receber spool no mesmo trabalho até que ocorra uma chamada EndDoc.

int StartDoc(LPDOCINFO lpDocInfo);
int StartDoc(LPCTSTR lpszDocName);

Parâmetros

lpDocInfo
Aponta para uma estrutura DOCINFO que contém o nome do arquivo de documento e o nome do arquivo de saída.

lpszDocName
Um ponteiro para uma cadeia de caracteres contendo o nome de arquivo do documento.

Valor de Devolução

Se a função obtiver êxito, o valor retornado será maior que zero. Esse valor é o identificador do trabalho de impressão do documento.

Se a função falhar, o valor retornado será menor ou igual a zero.

Comentários

Isso garante que documentos com mais de uma página não sejam intercalados com outros trabalhos.

Para versões do Windows 3.1 e posteriores, essa função substitui o escape de impressora STARTDOC. O uso dessa função garante que documentos contendo mais de uma página não sejam intercalados com outros trabalhos de impressão.

StartDoc não deve ser usado dentro de metaarquivos.

Exemplo

Esse fragmento de código obtém a impressora padrão, abre um trabalho de impressão e faz spool em uma página com "Hello, World!" nela. Como o texto impresso por esse código não é dimensionado para as unidades lógicas da impressora, o texto de saída pode estar em letras tão pequenas que o resultado se torna ilegível. As funções de dimensionamento CDC, como SetMapMode, SetViewportOrg e SetWindowExt, podem ser usadas para corrigir a escala.

void CDCView::DoStartDoc()
{
   // get the default printer
   CPrintDialog dlg(FALSE);
   dlg.GetDefaults();

   // is a default printer set up?
   HDC hdcPrinter = dlg.GetPrinterDC();
   if (hdcPrinter == NULL)
   {
      MessageBox(_T("Buy a printer!"));
   }
   else
   {
      // create a CDC and attach it to the default printer
      CDC dcPrinter;
      dcPrinter.Attach(hdcPrinter);

      // call StartDoc() to begin printing
      DOCINFO docinfo;
      memset(&docinfo, 0, sizeof(docinfo));
      docinfo.cbSize = sizeof(docinfo);
      docinfo.lpszDocName = _T("CDC::StartDoc() Code Fragment");

      // if it fails, complain and exit gracefully
      if (dcPrinter.StartDoc(&docinfo) < 0)
      {
         MessageBox(_T("Printer wouldn't initialize"));
      }
      else
      {
         // start a page
         if (dcPrinter.StartPage() < 0)
         {
            MessageBox(_T("Could not start page"));
            dcPrinter.AbortDoc();
         }
         else
         {
            // actually do some printing
            CGdiObject *pOldFont = dcPrinter.SelectStockObject(SYSTEM_FONT);

            dcPrinter.TextOut(50, 50, _T("Hello World!"), 12);

            dcPrinter.EndPage();
            dcPrinter.EndDoc();
            dcPrinter.SelectObject(pOldFont);
         }
      }
   }
}

CDC::StartPage

Chame essa função de membro para preparar o driver da impressora para receber dados.

int StartPage();

Valor de Devolução

Maior ou igual a 0 se a função tiver êxito, ou um valor negativo se tiver ocorrido um erro.

Comentários

StartPage substitui o NEWFRAME e BANDINFO escapa.

Para obter uma visão geral da sequência de chamadas de impressão, consulte a função de membro StartDoc.

O sistema desabilita a função de membro ResetDC entre chamadas para StartPage e EndPage.

Exemplo

Confira o exemplo de CDC::StartDoc.

CDC::StretchBlt

Copia um bitmap de um retângulo de origem em um retângulo de destino, alongando-o ou compactando-o, se necessário, para ajustá-lo às dimensões do retângulo de destino.

BOOL StretchBlt(
    int x,
    int y,
    int nWidth,
    int nHeight,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    int nSrcWidth,
    int nSrcHeight,
    DWORD dwRop);

Parâmetros

x
Especifica a coordenada x (em unidades lógicas) do canto esquerdo superior do retângulo de destino.

y
Especifica a coordenada y (em unidades lógicas) do canto esquerdo superior do retângulo de destino.

nWidth
Especifica a largura (em unidades lógicas) do retângulo de destino.

nHeight
Especifica a altura (em unidades lógicas) do retângulo de destino.

pSrcDC
Especifica o contexto do dispositivo de origem.

xSrc
Especifica a coordenada x (em unidades lógicas) do canto esquerdo superior do retângulo de origem.

ySrc
Especifica a coordenada y (em unidades lógicas) do canto esquerdo superior do retângulo de origem.

nSrcWidth
Especifica a largura (em unidades lógicas) do retângulo de origem.

nSrcHeight
Especifica a altura (em unidades lógicas) do retângulo de origem.

dwRop
Especifica a operação de varredura a ser executada. Os códigos da operação de varredura definem como a GDI combina cores nas operações de saída que envolvem um pincel, um possível bitmap de origem e um bitmap de destino. Esse parâmetro pode ser um dos seguintes valores:

  • BLACKNESS Faz com que toda a saída seja preta.

  • DSTINVERT Inverte o bitmap de destino.

  • MERGECOPY Combina o padrão e o bitmap de origem usando o operador booliano AND.

  • MERGEPAINTCombina o bitmap de origem invertido com o bitmap de destino usando o operador booliano OR.

  • NOTSRCCOPY Copia o bitmap de origem invertido para o destino.

  • NOTSRCERASE Inverte o resultado da combinação de bitmaps de destino e origem usando o operador booliano OR.

  • PATCOPY Copia o padrão para o bitmap de destino.

  • PATINVERT Combina o bitmap de destino com o padrão usando o operador booliano XOR.

  • PATPAINTCombina o bitmap de origem invertido com o padrão usando o operador booliano OR. Combina o resultado dessa operação com o bitmap de destino usando o operador booliano OR.

  • SRCAND Combina pixels dos bitmaps de origem e de destino usando o operador booliano AND.

  • SRCCOPY Copia o bitmap de origem para o bitmap de destino.

  • SRCERASEInverte o bitmap de destino e combina o resultado com o bitmap de origem usando o operador booliano AND.

  • SRCINVERT Combina pixels dos bitmaps de origem e de destino usando o operador booliano XOR.

  • SRCPAINT Combina pixels dos bitmaps de origem e de destino usando o operador booliano OR.

  • WHITENESS Faz com que toda a saída seja branca.

Valor de Devolução

Diferente de zero se o bitmap for desenhado; caso contrário, 0.

Comentários

A função usa o modo de alongamento do contexto do dispositivo de destino (definido por SetStretchBltMode) para determinar como alongar ou compactar o bitmap.

A função StretchBlt move o bitmap do dispositivo de origem fornecido por pSrcDC para o dispositivo de destino representado pelo objeto de contexto de dispositivo, cuja função membro está sendo chamada. Os parâmetros xSrc, ySrc, nSrcWidth e nSrcHeight definem o canto superior esquerdo e as dimensões do retângulo de origem. Os parâmetros x, y, nWidth e nHeight fornecem o canto superior esquerdo e as dimensões do retângulo de destino. A operação de varredura especificada por dwRop define como o bitmap de origem e os bits já no dispositivo de destino são combinados.

A função StretchBlt criará uma imagem espelhada de um bitmap se os sinais dos parâmetros nSrcWidth e nWidth ou nSrcHeight e nHeight forem diferentes. Se nSrcWidth e nWidth tiverem sinais diferentes, a função criará uma imagem espelhada do bitmap ao longo do eixo x. Se nSrcHeight e nHeight tiverem sinais diferentes, a função criará uma imagem espelhada do bitmap ao longo do eixo y.

A função StretchBlt alonga ou compacta o bitmap de origem na memória e copia o resultado no destino. Se um padrão for mesclado com o resultado, ele não será mesclado até que o bitmap de origem estendido seja copiado para o destino. Se um pincel for usado, ele será o pincel selecionado no contexto do dispositivo de destino. As coordenadas de destino são transformadas de acordo com o contexto do dispositivo de destino; as coordenadas de origem são transformadas de acordo com o contexto do dispositivo de origem.

Se os bitmaps de destino, origem e padrão não tiverem o mesmo formato de cor, StretchBlt converte os bitmaps de origem e de padrão para corresponder aos bitmaps de destino. As cores do primeiro plano e do plano de fundo do contexto do dispositivo de destino são usadas na conversão.

Se StretchBlt precisar converter um bitmap monocromático em colorido, ele definirá bits brancos (1) para a cor do plano de fundo e bits pretos (0) para a cor do primeiro plano. Para converter o colorido em monocromático, ele define pixels que correspondam à cor do plano de fundo para branco (1) e define todos os outros pixels para preto (0). As cores do primeiro plano e do plano de fundo do contexto do dispositivo com cor são usadas.

Nem todos os dispositivos oferecem suporte à função StretchBlt. Para determinar se um dispositivo oferece suporte a StretchBlt, chame a função de membro GetDeviceCaps com o índice RASTERCAPS e verifique o valor de retorno para o sinalizador RC_STRETCHBLT.

CDC::StrokeAndFillPath

Fecha as figuras abertas em um caminho, traça a estrutura de tópicos do caminho usando a caneta atual e preenche seu interior usando o pincel atual.

BOOL StrokeAndFillPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O contexto do dispositivo deve conter um caminho fechado. A StrokeAndFillPath função de membro tem o mesmo efeito que fechar todas as figuras abertas no caminho e acariciar e preencher o caminho separadamente, exceto que a região preenchida não se sobrepõe à região traçada, mesmo que a caneta seja larga.

CDC::StrokePath

Renderiza o caminho especificado usando a caneta atual.

BOOL StrokePath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

O contexto do dispositivo deve conter um caminho fechado.

CDC::TabbedTextOut

Chame essa função de membro para gravar uma cadeia de caracteres no local especificado, expandindo as guias para os valores especificados na matriz de posições de parada de tabulação.

virtual CSize TabbedTextOut(
    int x,
    int y,
    LPCTSTR lpszString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions,
    int nTabOrigin);

CSize TabbedTextOut(
    int x,
    int y,
    const CString& str,
    int nTabPositions,
    LPINT lpnTabStopPositions,
    int nTabOrigin);

Parâmetros

x
Especifica a coordenada x lógica do ponto de partida da cadeia de caracteres.

y
Especifica a coordenada y lógica do ponto de partida da cadeia de caracteres.

lpszString
Aponta para a cadeia de caracteres que será desenhada. Você pode passar um ponteiro para uma matriz de caracteres ou um objeto CString para esse parâmetro.

nCount
Especifica o tamanho da cadeia de caracteres. apontada por lpszString.

nTabPositions
Especifica o número de valores na matriz de posições de parada de tabulação.

lpnTabStopPositions
Aponta para uma matriz que contém as posições tab-stop (em unidades lógicas). As paradas de tabulação devem ser classificadas em ordem crescente; o menor valor x deve ser o primeiro item na matriz.

nTabOrigin
Especifica a coordenada x da posição inicial da qual as guias são expandidas (em unidades lógicas).

str
Um objeto CString que contém os caracteres especificados.

Valor de Devolução

As dimensões da cadeia de caracteres (em unidades lógicas) como um objeto CSize.

Comentários

O texto é gravado na fonte selecionada atualmente. Se nTabPositions for 0 e lpnTabStopPositions for NULL, as guias serão expandidas para oito vezes a largura média dos caracteres.

Se nTabPositions for 1, as paradas de tabulação serão separadas pela distância especificada pelo primeiro valor na matriz lpnTabStopPositions. Se a matriz lpnTabStopPositions contiver mais de um único valor, uma parada de tabulação será definida para cada valor na matriz, até o número especificado por nTabPositions. O parâmetro nTabOrigin permite que um aplicativo chame a função TabbedTextOut várias vezes para uma única linha. Se o aplicativo chamar a função mais de uma vez com nTabOrigin definido como o mesmo valor a cada vez, a função expandirá todas as guias em relação à posição especificada por nTabOrigin.

Por padrão, a posição atual não é usada ou atualizada pela função. Se um aplicativo precisar atualizar a posição atual quando chamar a função, o aplicativo poderá chamar a função de membro SetTextAlign com nFlags definido como TA_UPDATECP. Quando esse sinalizador é definido, o Windows ignora os parâmetros x e y em chamadas subsequentes para TabbedTextOut, usando a posição atual em vez disso.

CDC::TextOut

Grava uma cadeia de caracteres no local especificado usando a fonte selecionada no momento.

virtual BOOL TextOut(
    int x,
    int y,
    LPCTSTR lpszString,
    int nCount);

BOOL TextOut(
    int x,
    int y,
    const CString& str);

Parâmetros

x
Especifica a coordenada x lógica do ponto de partida do texto.

y
Especifica a coordenada y lógica do ponto de partida do texto.

lpszString
Aponta para a cadeia de caracteres a ser desenhada.

nCount
Especifica o número de caracteres na cadeia de caracteres.

str
Um objeto CString que contém os caracteres a serem desenhados.

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

As origens do caractere estão no canto superior esquerdo da célula do caractere. Por padrão, a posição atual não é usada ou atualizada pela função.

Se um aplicativo precisar atualizar a posição atual quando chamar TextOut, o aplicativo poderá chamar a função de membro SetTextAlign com nFlags definido como TA_UPDATECP. Quando esse sinalizador é definido, o Windows ignora os parâmetros x e y em chamadas subsequentes para TextOut, usando a posição atual em vez disso.

Exemplo

Confira o exemplo de CDC::BeginPath.

CDC::TransparentBlt

Chame essa função de membro para transferir um bloco de bits dos dados de cor, que corresponde a um retângulo de pixels do contexto de dispositivo de origem especificado, para um contexto de dispositivo de destino.

BOOL TransparentBlt(
    int xDest,
    int yDest,
    int nDestWidth,
    int nDestHeight,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    int nSrcWidth,
    int nSrcHeight,
    UINT clrTransparent);

Parâmetros

xDest
Especifica a coordenada x, em unidades lógicas, do canto esquerdo superior do retângulo de destino.

yDest
Especifica a coordenada y, em unidades lógicas, do canto esquerdo superior do retângulo de destino.

nDestWidth
Especifica a largura, em unidades lógicas, do retângulo de destino.

nDestHeight
Especifica a altura, em unidades lógicas, do retângulo de destino.

pSrcDC
Ponteiro para o contexto de dispositivo de origem.

xSrc
Especifica a coordenada x, em unidades lógicas, do retângulo de origem.

ySrc
Especifica a coordenada y, em unidades lógicas, do retângulo de origem.

nSrcWidth
Especifica a largura, em unidades lógicas, do retângulo de origem.

nSrcHeight
Especifica a altura, em unidades lógicas, do retângulo de origem.

clrTransparent
A cor RGB no bitmap de origem a ser tratada como transparente.

Valor de Devolução

TRUE se for bem-sucedido, caso contrário, FALSE.

Comentários

TransparentBlt permite transparência; ou seja, a cor RGB indicada por clrTransparent é renderizada como transparente para a transferência.

Para obter mais informações, consulte TransparentBlt no SDK do Windows.

CDC::UpdateColors

Atualiza a área do cliente do contexto do dispositivo, combinando as cores atuais na área do cliente com a paleta do sistema em uma base pixel a pixel.

void UpdateColors();

Comentários

Uma janela inativa com uma paleta lógica realizada pode chamar UpdateColors como alternativa para redesenhar sua área de cliente quando a paleta do sistema for alterada.

Para obter mais informações sobre como usar paletas de cores, consulte UpdateColors no SDK do Windows.

A função de membro UpdateColors normalmente atualiza uma área do cliente mais rapidamente do que redesenhar a área. No entanto, como a função executa a tradução de cores com base na cor de cada pixel antes da paleta do sistema ser alterada, cada chamada para essa função resulta na perda de alguma precisão de cor.

CDC::WidenPath

Redefine o caminho atual como a área que seria pintada se o caminho fosse traçado usando a caneta selecionada atualmente no contexto do dispositivo.

BOOL WidenPath();

Valor de Devolução

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Comentários

Essa função só será bem-sucedida se a caneta atual for uma caneta geométrica criada pela segunda versão da função de membro CreatePen ou se a caneta for criada com a primeira versão de CreatePen e tiver uma largura, em unidades de dispositivo, maior que 1. O contexto do dispositivo deve conter um caminho fechado. Todas as curvas Bzier no caminho são convertidas em sequências de linhas retas aproximando as curvas ampliadas. Dessa forma, nenhuma curva Bzier permanece no caminho depois de WidenPath ser chamado.

Confira também

Classe CObject
Gráfico da hierarquia
Classe CPaintDC
Classe CWindowDC
Classe CClientDC
Classe CMetaFileDC