mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-15 06:05:58 -06:00
34ff691308
This might bring some incompatibilities in the code that expects wchar to be 16 bit, which escpecially involves dealing with Win32 (and to lesser extend MacOS) APIs, so if your application is doing that, please check all instances of WCHAR (UniChar on MacOS) or even wchar especially type casts. To support host APIs, char16 is introduced (but there is no 16-bit String varian). Use ToSystemCharsetW, FromSystemCharsetW to convert texts to Win32 API. - Support of drawing non-BMP characters in GUI - Vastly improved character font replacement code (when drawing characters missing with requested font, replacement font is used) - Last instances of Win32 ANSI calls (those ending with A) are removed - UTF handling routines are refactored and their's naming is unified - RTF is now being able to handle non-BMP characters (RTF is used as clipboard format for RichText) Other minor changes: - fixed TryRealloc issue - improved MemoryCheck - Removed MemoryAlloc48/MemoryFree48 - In theide Background parsing should less often cause delays in the main thread
489 lines
11 KiB
C++
489 lines
11 KiB
C++
#include "CtrlCore.h"
|
|
|
|
#ifdef GUI_WIN
|
|
|
|
namespace Upp {
|
|
|
|
#define LLOG(x) // LOG(x)
|
|
#define LTIMING(x) // RTIMING(x)
|
|
|
|
static COLORREF sLightGray;
|
|
|
|
Rect SystemDraw::GetVirtualScreenArea()
|
|
{
|
|
GuiLock __;
|
|
return RectC(GetSystemMetrics(SM_XVIRTUALSCREEN),
|
|
GetSystemMetrics(SM_YVIRTUALSCREEN),
|
|
GetSystemMetrics(SM_CXVIRTUALSCREEN),
|
|
GetSystemMetrics(SM_CYVIRTUALSCREEN));
|
|
}
|
|
|
|
dword SystemDraw::GetInfo() const
|
|
{
|
|
return DATABANDS|(native || !(style & DOTS) ? style|NATIVE : style);
|
|
}
|
|
|
|
Size SystemDraw::GetPageSize() const
|
|
{
|
|
return native && Dots() ? nativeSize : pageSize;
|
|
}
|
|
|
|
Size SystemDraw::GetNativeDpi() const
|
|
{
|
|
return nativeDpi;
|
|
}
|
|
|
|
#ifndef PLATFORM_WINCE
|
|
void Add(LOGPALETTE *pal, int r, int g, int b)
|
|
{
|
|
pal->palPalEntry[pal->palNumEntries].peRed = min(r, 255);
|
|
pal->palPalEntry[pal->palNumEntries].peGreen = min(g, 255);
|
|
pal->palPalEntry[pal->palNumEntries].peBlue = min(b, 255);
|
|
pal->palPalEntry[pal->palNumEntries++].peFlags = PC_NOCOLLAPSE;
|
|
}
|
|
|
|
HPALETTE GetQlibPalette()
|
|
{
|
|
static HPALETTE hQlibPalette;
|
|
if(hQlibPalette) return hQlibPalette;
|
|
SystemDraw::InitColors();
|
|
LOGPALETTE *pal = (LOGPALETTE *) new byte[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
|
|
pal->palNumEntries = 0;
|
|
pal->palVersion = 0x300;
|
|
for(int r = 0; r < 6; r++)
|
|
for(int g = 0; g < 6; g++)
|
|
for(int b = 0; b < 6; b++)
|
|
Add(pal, 255 * r / 5, 255 * g / 5, 255 * b / 5);
|
|
for(int q = 0; q <= 16; q++)
|
|
Add(pal, 16 * q, 16 * q, 16 * q);
|
|
Add(pal, GetRValue(sLightGray), GetGValue(sLightGray), GetBValue(sLightGray));
|
|
hQlibPalette = CreatePalette(pal);
|
|
delete[] pal;
|
|
return hQlibPalette;
|
|
}
|
|
#endif
|
|
|
|
SystemDraw& ScreenInfo()
|
|
{
|
|
static ScreenDraw sd(true);
|
|
return sd;
|
|
}
|
|
|
|
HDC ScreenHDC()
|
|
{
|
|
static HDC hdc;
|
|
ONCELOCK {
|
|
hdc = CreateDC("DISPLAY", NULL, NULL, NULL);
|
|
}
|
|
return hdc;
|
|
}
|
|
|
|
static bool _AutoPalette = true;
|
|
bool SystemDraw::AutoPalette() { return _AutoPalette; }
|
|
void SystemDraw::SetAutoPalette(bool ap) { _AutoPalette = ap; }
|
|
|
|
COLORREF SystemDraw::GetColor(Color c) const {
|
|
COLORREF color = c;
|
|
#ifdef PLATFORM_WINCE
|
|
return color;
|
|
#else
|
|
if(!palette)
|
|
return color;
|
|
static Index<dword> *SColor;
|
|
ONCELOCK {
|
|
static Index<dword> StaticColor;
|
|
StaticColor << RGB(0x00, 0x00, 0x00) << RGB(0x80, 0x00, 0x00) << RGB(0x00, 0x80, 0x00)
|
|
<< RGB(0x80, 0x80, 0x00) << RGB(0x00, 0x00, 0x80) << RGB(0x80, 0x00, 0x80)
|
|
<< RGB(0x00, 0x80, 0x80) << RGB(0xC0, 0xC0, 0xC0) << RGB(0xC0, 0xDC, 0xC0)
|
|
<< RGB(0xA6, 0xCA, 0xF0) << RGB(0xFF, 0xFB, 0xF0) << RGB(0xA0, 0xA0, 0xA4)
|
|
<< RGB(0x80, 0x80, 0x80) << RGB(0xFF, 0x00, 0x00) << RGB(0x00, 0xFF, 0x00)
|
|
<< RGB(0xFF, 0xFF, 0x00) << RGB(0x00, 0x00, 0xFF) << RGB(0xFF, 0x00, 0xFF)
|
|
<< RGB(0x00, 0xFF, 0xFF) << RGB(0xFF, 0xFF, 0xFF);
|
|
SColor = &StaticColor;
|
|
}
|
|
if(color16 || !AutoPalette())
|
|
return GetNearestColor(handle, color);
|
|
if(SColor->Find(color) >= 0)
|
|
return color;
|
|
if(color == sLightGray)
|
|
return PALETTEINDEX(216 + 17);
|
|
int r = GetRValue(color);
|
|
int g = GetGValue(color);
|
|
int b = GetBValue(color);
|
|
return PALETTEINDEX(r == g && g == b ? (r + 8) / 16 + 216
|
|
: (r + 25) / 51 * 36 +
|
|
(g + 25) / 51 * 6 +
|
|
(b + 25) / 51);
|
|
#endif
|
|
}
|
|
|
|
void SystemDraw::InitColors()
|
|
{
|
|
}
|
|
|
|
void SystemDraw::SetColor(Color color)
|
|
{
|
|
GuiLock __;
|
|
LLOG("SetColor " << color);
|
|
if(color != lastColor) {
|
|
LLOG("Setting, lastColor:" << FormatIntHex(lastColor.GetRaw())
|
|
<< " color:" << FormatIntHex(color.GetRaw()) <<
|
|
" GetColor:" << FormatIntHex(GetColor(color)) << " palette:" << palette);
|
|
HBRUSH oldBrush = actBrush;
|
|
HBRUSH h;
|
|
if(!IsNull(color))
|
|
h = (HBRUSH) SelectObject(handle, actBrush = CreateSolidBrush(GetColor(color)));
|
|
else {
|
|
HGDIOBJ empty = GetStockObject(HOLLOW_BRUSH);
|
|
h = (HBRUSH) SelectObject(handle, empty);
|
|
actBrush = NULL;
|
|
}
|
|
ASSERT(h);
|
|
if(!orgBrush) orgBrush = h;
|
|
if(oldBrush) DeleteObject(oldBrush);
|
|
lastColor = color;
|
|
}
|
|
}
|
|
|
|
void SystemDraw::SetDrawPen(int width, Color color) {
|
|
GuiLock __;
|
|
if(IsNull(width))
|
|
width = PEN_NULL;
|
|
if(width != lastPen || color != lastPenColor) {
|
|
static int penstyle[] = {
|
|
PS_NULL, PS_SOLID, PS_DASH,
|
|
#ifndef PLATFORM_WINCE
|
|
PS_DOT, PS_DASHDOT, PS_DASHDOTDOT
|
|
#endif
|
|
};
|
|
HPEN oldPen = actPen;
|
|
actPen = CreatePen(width < 0 ? penstyle[-width - 1] : PS_SOLID,
|
|
width < 0 ? 0 : width, GetColor(color));
|
|
HPEN h = (HPEN) SelectObject(handle, actPen);
|
|
if(!orgPen) orgPen = h;
|
|
if(oldPen) DeleteObject(oldPen);
|
|
lastPen = width;
|
|
lastPenColor = color;
|
|
}
|
|
}
|
|
|
|
void SystemDraw::SetOrg() {
|
|
GuiLock __;
|
|
#ifdef PLATFORM_WINCE
|
|
::SetViewportOrgEx(handle, actual_offset.x, actual_offset.y, 0);
|
|
#else
|
|
LLOG("SystemDraw::SetOrg: clip = " << GetClip() << ", offset = " << actual_offset);
|
|
::SetWindowOrgEx(handle, -actual_offset.x, -actual_offset.y, 0);
|
|
LLOG("//SystemDraw::SetOrg: clip = " << GetClip());
|
|
#endif
|
|
}
|
|
|
|
#ifndef PLATFORM_WINCE
|
|
Point SystemDraw::LPtoDP(Point p) const {
|
|
GuiLock __;
|
|
::LPtoDP(handle, p, 1);
|
|
return p;
|
|
}
|
|
|
|
Point SystemDraw::DPtoLP(Point p) const {
|
|
GuiLock __;
|
|
::DPtoLP(handle, p, 1);
|
|
return p;
|
|
}
|
|
|
|
Rect SystemDraw::LPtoDP(const Rect& r) const {
|
|
GuiLock __;
|
|
Rect w = r;
|
|
::LPtoDP(handle, reinterpret_cast<POINT *>(&w), 2);
|
|
return w;
|
|
}
|
|
|
|
Rect SystemDraw::DPtoLP(const Rect& r) const {
|
|
GuiLock __;
|
|
Rect w = r;
|
|
::LPtoDP(handle, reinterpret_cast<POINT *>(&w), 2);
|
|
return w;
|
|
}
|
|
#endif
|
|
|
|
Size SystemDraw::GetSizeCaps(int i, int j) const {
|
|
GuiLock __;
|
|
return Size(GetDeviceCaps(handle, i), GetDeviceCaps(handle, j));
|
|
}
|
|
|
|
void SystemDraw::DotsMode()
|
|
{
|
|
::SetMapMode(handle, MM_ANISOTROPIC);
|
|
::SetViewportExtEx(handle, nativeDpi.cx, nativeDpi.cy, NULL);
|
|
::SetViewportOrgEx(handle, 0, 0, NULL);
|
|
::SetWindowExtEx(handle, 600, 600, NULL);
|
|
::SetWindowOrgEx(handle, 0, 0, NULL);
|
|
}
|
|
|
|
void SystemDraw::BeginNative()
|
|
{
|
|
if(GetPixelsPerInch() != nativeDpi && ++native == 1) {
|
|
::SetMapMode(handle, MM_TEXT);
|
|
actual_offset_bak = actual_offset;
|
|
Native(actual_offset);
|
|
SetOrg();
|
|
}
|
|
}
|
|
|
|
void SystemDraw::EndNative()
|
|
{
|
|
if(GetPixelsPerInch() == nativeDpi && --native == 0) {
|
|
DotsMode();
|
|
actual_offset = actual_offset_bak;
|
|
SetOrg();
|
|
}
|
|
}
|
|
|
|
int SystemDraw::GetCloffLevel() const
|
|
{
|
|
return cloff.GetCount();
|
|
}
|
|
|
|
void SystemDraw::LoadCaps() {
|
|
GuiLock __;
|
|
color16 = false;
|
|
palette = (GetDeviceCaps(handle, RASTERCAPS) & RC_PALETTE);
|
|
if(palette)
|
|
color16 = GetDeviceCaps(handle, SIZEPALETTE) != 256;
|
|
nativeSize = pageSize = GetSizeCaps(HORZRES, VERTRES);
|
|
nativeDpi = GetSizeCaps(LOGPIXELSX, LOGPIXELSY);
|
|
is_mono = GetDeviceCaps(handle, BITSPIXEL) == 1 && GetDeviceCaps(handle, PLANES) == 1;
|
|
}
|
|
|
|
void SystemDraw::Cinit() {
|
|
GuiLock __;
|
|
lastColor = Color::FromCR(COLORREF(-5));
|
|
lastPenColor = Color::FromCR(COLORREF(-5));
|
|
lastTextColor = COLORREF(-1);
|
|
lastPen = Null;
|
|
actBrush = orgBrush = NULL;
|
|
actPen = orgPen = NULL;
|
|
}
|
|
|
|
void SystemDraw::Init() {
|
|
GuiLock __;
|
|
drawingclip = Rect(-(INT_MAX >> 1), -(INT_MAX >> 1), +(INT_MAX >> 1), +(INT_MAX >> 1));
|
|
Cinit();
|
|
SetBkMode(handle, TRANSPARENT);
|
|
::SetTextAlign(handle, TA_BASELINE);
|
|
#ifdef PLATFORM_WINCE
|
|
actual_offset = Point(0, 0);
|
|
#else
|
|
::GetViewportOrgEx(handle, actual_offset);
|
|
#endif
|
|
LoadCaps();
|
|
}
|
|
|
|
void SystemDraw::InitClip(const Rect& clip)
|
|
{
|
|
drawingclip = clip;
|
|
}
|
|
|
|
void SystemDraw::Reset() {
|
|
GuiLock __;
|
|
style = 0;
|
|
}
|
|
|
|
SystemDraw::SystemDraw() {
|
|
GuiLock __;
|
|
native = 0;
|
|
InitColors();
|
|
actual_offset = Point(0, 0);
|
|
Reset();
|
|
handle = NULL;
|
|
dcMem = NULL;
|
|
}
|
|
|
|
SystemDraw::SystemDraw(HDC hdc) {
|
|
GuiLock __;
|
|
native = 0;
|
|
InitColors();
|
|
Reset();
|
|
Attach(hdc);
|
|
}
|
|
|
|
void SystemDraw::Unselect0() {
|
|
GuiLock __;
|
|
if(orgPen) SelectObject(handle, orgPen);
|
|
if(orgBrush) SelectObject(handle, orgBrush);
|
|
if(actPen) DeleteObject(actPen);
|
|
if(actBrush) DeleteObject(actBrush);
|
|
Cinit();
|
|
}
|
|
|
|
void SystemDraw::Unselect() {
|
|
GuiLock __;
|
|
while(cloff.GetCount())
|
|
End();
|
|
Unselect0();
|
|
}
|
|
|
|
void SystemDraw::Attach(HDC ahandle)
|
|
{
|
|
handle = ahandle;
|
|
dcMem = ::CreateCompatibleDC(handle);
|
|
Init();
|
|
}
|
|
|
|
HDC SystemDraw::Detach()
|
|
{
|
|
Unselect();
|
|
HDC h = handle;
|
|
handle = NULL;
|
|
::DeleteDC(dcMem);
|
|
dcMem = NULL;
|
|
return h;
|
|
}
|
|
|
|
SystemDraw::~SystemDraw() {
|
|
GuiLock __;
|
|
Detach();
|
|
}
|
|
|
|
HDC SystemDraw::BeginGdi() {
|
|
GuiLock __;
|
|
Begin();
|
|
return handle;
|
|
}
|
|
|
|
void SystemDraw::EndGdi() {
|
|
GuiLock __;
|
|
Unselect0();
|
|
End();
|
|
}
|
|
|
|
void BackDraw::Create(SystemDraw& w, int cx, int cy) {
|
|
ASSERT(w.GetHandle());
|
|
GuiLock __;
|
|
Destroy();
|
|
size.cx = cx;
|
|
size.cy = cy;
|
|
hbmp = ::CreateCompatibleBitmap(w.GetHandle(), cx, cy);
|
|
handle = ::CreateCompatibleDC(w.GetHandle());
|
|
dcMem = ::CreateCompatibleDC(handle);
|
|
ASSERT(hbmp);
|
|
ASSERT(handle);
|
|
#ifndef PLATFORM_WINCE
|
|
if(AutoPalette()) {
|
|
::SelectPalette(handle, GetQlibPalette(), FALSE);
|
|
::RealizePalette(handle);
|
|
}
|
|
#endif
|
|
hbmpold = (HBITMAP) ::SelectObject(handle, hbmp);
|
|
Init();
|
|
InitClip(size);
|
|
}
|
|
|
|
void BackDraw::Put(SystemDraw& w, int x, int y) {
|
|
GuiLock __;
|
|
ASSERT(handle);
|
|
LTIMING("BackDraw::Put");
|
|
#ifdef PLATFORM_WINCE
|
|
::SetViewportOrgEx(handle, 0, 0, 0);
|
|
#else
|
|
::SetWindowOrgEx(handle, 0, 0, NULL);
|
|
#endif
|
|
::BitBlt(w, x, y, size.cx, size.cy, *this, 0, 0, SRCCOPY);
|
|
}
|
|
|
|
void BackDraw::Destroy() {
|
|
GuiLock __;
|
|
if(handle) {
|
|
Unselect();
|
|
::SelectObject(handle, hbmpold);
|
|
::DeleteDC(handle);
|
|
::DeleteObject(hbmp);
|
|
handle = NULL;
|
|
::DeleteDC(dcMem);
|
|
dcMem = NULL;
|
|
}
|
|
}
|
|
|
|
ScreenDraw::ScreenDraw(bool ic) {
|
|
GuiLock __;
|
|
#ifdef PLATFORM_WINCE
|
|
Attach(CreateDC(NULL, NULL, NULL, NULL));
|
|
#else
|
|
Attach(ic ? CreateIC("DISPLAY", NULL, NULL, NULL) : CreateDC("DISPLAY", NULL, NULL, NULL));
|
|
InitClip(GetVirtualScreenArea());
|
|
if(AutoPalette()) {
|
|
SelectPalette(handle, GetQlibPalette(), TRUE);
|
|
RealizePalette(handle);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
ScreenDraw::~ScreenDraw() {
|
|
GuiLock __;
|
|
Unselect();
|
|
DeleteDC(handle);
|
|
}
|
|
|
|
#ifndef PLATFORM_WINCE
|
|
|
|
void PrintDraw::InitPrinter()
|
|
{
|
|
GuiLock __;
|
|
Init();
|
|
style = PRINTER|DOTS;
|
|
DotsMode();
|
|
native = 0;
|
|
actual_offset = Point(0, 0);
|
|
aborted = false;
|
|
pageSize.cx = 600 * nativeSize.cx / nativeDpi.cx;
|
|
pageSize.cy = 600 * nativeSize.cy / nativeDpi.cy;
|
|
InitClip(pageSize);
|
|
}
|
|
|
|
void PrintDraw::StartPage()
|
|
{
|
|
GuiLock __;
|
|
if(aborted) return;
|
|
Unselect();
|
|
if(::StartPage(handle) <= 0)
|
|
aborted = true;
|
|
else
|
|
InitPrinter();
|
|
}
|
|
|
|
void PrintDraw::EndPage()
|
|
{
|
|
GuiLock __;
|
|
if(aborted) return;
|
|
Unselect();
|
|
if(::EndPage(handle) <= 0)
|
|
aborted = true;
|
|
}
|
|
|
|
PrintDraw::PrintDraw(HDC hdc, const char *docname)
|
|
: SystemDraw(hdc)
|
|
{
|
|
GuiLock __;
|
|
DOCINFOW di;
|
|
memset(&di, 0, sizeof(di));
|
|
di.cbSize = sizeof(di);
|
|
Vector<char16> sys_docname = ToSystemCharsetW(docname);
|
|
di.lpszDocName = sys_docname;
|
|
if(::StartDocW(hdc, &di) <= 0)
|
|
aborted = true;
|
|
else
|
|
InitPrinter();
|
|
}
|
|
|
|
PrintDraw::~PrintDraw() {
|
|
GuiLock __;
|
|
if(aborted)
|
|
::AbortDoc(handle);
|
|
else
|
|
::EndDoc(handle);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|