include(CheckIncludeFiles)
include(CheckFunctionExists)
include(CheckLibraryExists)
+include(CheckVariableExists)
include(CheckTypeSize)
include(CheckCSourceCompiles)
include(CheckCXXSourceCompiles)
add_definitions("-DHAVE_H264")
set(H264_LIBS "WIN") # may be LIBAV in the future
set(H264_LIBRARIES ole32 mfplat mfuuid wmcodecdspuuid)
+
+ set(CMAKE_REQUIRED_LIBRARIES ${H264_LIBRARIES})
+ check_variable_exists(CLSID_VideoProcessorMFT HAVE_VIDEO_PROCESSOR_MFT)
+ set(CMAKE_REQUIRED_LIBRARIES)
+ if(HAVE_VIDEO_PROCESSOR_MFT)
+ add_definitions("-DHAVE_VIDEO_PROCESSOR_MFT")
+ endif()
else()
find_package(Ffmpeg)
if (AVCODEC_FOUND AND AVUTIL_FOUND AND SWSCALE_FOUND)
isShutdown_ = false;
}
-SocketListener::SocketListener(int fd)
- : fd(fd), filter(nullptr)
+SocketListener::SocketListener(int fd_)
+ : fd(fd_), filter(nullptr)
{
initSockets();
}
listen(sock);
}
-Socket* TcpListener::createSocket(int fd) {
- return new TcpSocket(fd);
+Socket* TcpListener::createSocket(int fd_) {
+ return new TcpSocket(fd_);
}
std::list<std::string> TcpListener::getMyAddresses() {
unlink(addr.sun_path);
}
-Socket* UnixListener::createSocket(int fd) {
- return new UnixSocket(fd);
+Socket* UnixListener::createSocket(int fd_) {
+ return new UnixSocket(fd_);
}
int UnixListener::getMyPort() {
#endif
}
-Condition::Condition(Mutex* mutex)
+Condition::Condition(Mutex* mutex_)
{
- this->mutex = mutex;
+ this->mutex = mutex_;
#ifdef WIN32
systemCondition = new CONDITION_VARIABLE;
{
if (!in->hasData(2))
return false;
- const uint8_t* ptr = in->getptr(2);
- size_t length = ((int)ptr[0] << 8) | (int)ptr[1];
+ const uint8_t* buf = in->getptr(2);
+ size_t length = ((int)buf[0] << 8) | (int)buf[1];
if (!in->hasData(2 + length + 16))
return false;
ensureSpace(length);
- ptr = in->getptr(2 + length + 16);
- const uint8_t* ad = ptr;
- const uint8_t* data = ptr + 2;
- const uint8_t* mac = ptr + 2 + length;
+ buf = in->getptr(2 + length + 16);
+ const uint8_t* ad = buf;
+ const uint8_t* data = buf + 2;
+ const uint8_t* mac = buf + 2 + length;
uint8_t macComputed[16];
if (keySize == 128) {
static const size_t DEFAULT_BUF_SIZE = 16384;
static const size_t MAX_BUF_SIZE = 32 * 1024 * 1024;
-BufferedOutStream::BufferedOutStream(bool emulateCork)
- : bufSize(DEFAULT_BUF_SIZE), offset(0), emulateCork(emulateCork)
+BufferedOutStream::BufferedOutStream(bool emulateCork_)
+ : bufSize(DEFAULT_BUF_SIZE), offset(0), emulateCork(emulateCork_)
{
ptr = start = sentUpTo = new uint8_t[bufSize];
end = start + bufSize;
va_end(ap);
}
-GAIException::GAIException(const char* s, int err)
- : Exception("%s", s)
+GAIException::GAIException(const char* s, int err_)
+ : Exception("%s", s), err(err_)
{
strncat(str_, ": ", len-1-strlen(str_));
#ifdef _WIN32
// FIXME: This conversion magic should be in CMsgWriter
std::string filtered(convertCRLF(data));
size_t sizes[1] = { filtered.size() + 1 };
- const uint8_t* data[1] = { (const uint8_t*)filtered.c_str() };
+ const uint8_t* datas[1] = { (const uint8_t*)filtered.c_str() };
if (unsolicitedClipboardAttempt) {
unsolicitedClipboardAttempt = false;
}
}
- writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, data);
+ writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, datas);
} else {
writer()->writeClientCutText(data);
}
bool CMsgReader::readLEDState()
{
- uint8_t state;
+ uint8_t ledState;
if (!is->hasData(1))
return false;
- state = is->readU8();
+ ledState = is->readU8();
- handler->setLEDState(state);
+ handler->setLEDState(ledState);
return true;
}
bool CMsgReader::readVMwareLEDState()
{
- uint32_t state;
+ uint32_t ledState;
if (!is->hasData(4))
return false;
- state = is->readU32();
+ ledState = is->readU32();
// As luck has it, this extension uses the same bit definitions,
// so no conversion required
- handler->setLEDState(state);
+ handler->setLEDState(ledState);
return true;
}
const int MinKeyLength = 128;
const int MaxKeyLength = 1024;
-CSecurityDH::CSecurityDH(CConnection* cc)
- : CSecurity(cc), keyLength(0)
+CSecurityDH::CSecurityDH(CConnection* cc_)
+ : CSecurity(cc_), keyLength(0)
{
mpz_init(g);
mpz_init(p);
using namespace rfb;
-CSecurityMSLogonII::CSecurityMSLogonII(CConnection* cc)
- : CSecurity(cc)
+CSecurityMSLogonII::CSecurityMSLogonII(CConnection* cc_)
+ : CSecurity(cc_)
{
mpz_init(g);
mpz_init(p);
class CSecurityNone : public CSecurity {
public:
- CSecurityNone(CConnection* cc) : CSecurity(cc) {}
+ CSecurityNone(CConnection* cc_) : CSecurity(cc_) {}
bool processMsg() override { return true; }
int getType() const override {return secTypeNone;}
};
class CSecurityPlain : public CSecurity {
public:
- CSecurityPlain(CConnection* cc) : CSecurity(cc) {}
+ CSecurityPlain(CConnection* cc_) : CSecurity(cc_) {}
bool processMsg() override;
int getType() const override { return secTypePlain; }
};
using namespace rfb;
-CSecurityRSAAES::CSecurityRSAAES(CConnection* cc, uint32_t _secType,
+CSecurityRSAAES::CSecurityRSAAES(CConnection* cc_, uint32_t _secType,
int _keySize, bool _isAllEncrypted)
- : CSecurity(cc), state(ReadPublicKey),
+ : CSecurity(cc_), state(ReadPublicKey),
keySize(_keySize), isAllEncrypted(_isAllEncrypted), secType(_secType),
clientKey(), clientPublicKey(), serverKey(),
serverKeyN(nullptr), serverKeyE(nullptr),
using namespace rfb;
-CSecurityStack::CSecurityStack(CConnection* cc, int Type,
+CSecurityStack::CSecurityStack(CConnection* cc_, int Type,
CSecurity* s0, CSecurity* s1)
- : CSecurity(cc), type(Type)
+ : CSecurity(cc_), type(Type)
{
state = 0;
state0 = s0;
return full_path;
}
-CSecurityTLS::CSecurityTLS(CConnection* cc, bool _anon)
- : CSecurity(cc), session(nullptr),
+CSecurityTLS::CSecurityTLS(CConnection* cc_, bool _anon)
+ : CSecurity(cc_), session(nullptr),
anon_cred(nullptr), cert_cred(nullptr),
anon(_anon), tlsis(nullptr), tlsos(nullptr),
rawis(nullptr), rawos(nullptr)
static LogWriter vlog("CVeNCrypt");
-CSecurityVeNCrypt::CSecurityVeNCrypt(CConnection* cc, SecurityClient* sec)
- : CSecurity(cc), csecurity(nullptr), security(sec)
+CSecurityVeNCrypt::CSecurityVeNCrypt(CConnection* cc_,
+ SecurityClient* sec)
+ : CSecurity(cc_), csecurity(nullptr), security(sec)
{
haveRecvdMajorVersion = false;
haveRecvdMinorVersion = false;
class CSecurityVncAuth : public CSecurity {
public:
- CSecurityVncAuth(CConnection* cc) : CSecurity(cc) {}
+ CSecurityVncAuth(CConnection* cc_) : CSecurity(cc_) {}
virtual ~CSecurityVncAuth() {}
bool processMsg() override;
int getType() const override {return secTypeVncAuth;};
return set(n, strlen(n), v, immutable);
}
-bool Configuration::set(const char* name, int len,
+bool Configuration::set(const char* paramName, int len,
const char* val, bool immutable)
{
VoidParameter* current = head;
while (current) {
if ((int)strlen(current->getName()) == len &&
- strncasecmp(current->getName(), name, len) == 0)
+ strncasecmp(current->getName(), paramName, len) == 0)
{
bool b = current->setParam(val);
if (b && immutable)
}
current = current->_next;
}
- return _next ? _next->set(name, len, val, immutable) : false;
+ return _next ? _next->set(paramName, len, val, immutable) : false;
}
bool Configuration::set(const char* config, bool immutable) {
static LogWriter vlog("Cursor");
Cursor::Cursor(int width, int height, const Point& hotspot,
- const uint8_t* data) :
+ const uint8_t* data_) :
width_(width), height_(height), hotspot_(hotspot)
{
- this->data = new uint8_t[width_*height_*4];
- memcpy(this->data, data, width_*height_*4);
+ data = new uint8_t[width_*height_*4];
+ memcpy(data, data_, width_*height_*4);
}
Cursor::Cursor(const Cursor& other) :
static LogWriter vlog("DecodeManager");
-DecodeManager::DecodeManager(CConnection *conn) :
- conn(conn), threadException(nullptr)
+DecodeManager::DecodeManager(CConnection *conn_) :
+ conn(conn_), threadException(nullptr)
{
size_t cpuCount;
throw e;
}
-DecodeManager::DecodeThread::DecodeThread(DecodeManager* manager)
+DecodeManager::DecodeThread::DecodeThread(DecodeManager* manager_)
+ : manager(manager_), stopRequested(false)
{
- this->manager = manager;
-
- stopRequested = false;
-
start();
}
using namespace rfb;
-Decoder::Decoder(enum DecoderFlags flags) : flags(flags)
+Decoder::Decoder(enum DecoderFlags flags_) : flags(flags_)
{
}
len = is->readU32();
os->writeU32(len);
- uint32_t flags = is->readU32();
+ uint32_t reset = is->readU32();
- os->writeU32(flags);
+ os->writeU32(reset);
if (!is->hasDataOrRestore(len))
return false;
{
rdr::MemInStream is(buffer, buflen);
uint32_t len = is.readU32();
- uint32_t flags = is.readU32();
+ uint32_t reset = is.readU32();
H264DecoderContext* ctx = nullptr;
- if (flags & resetAllContexts)
+ if (reset & resetAllContexts)
{
resetContexts();
if (!len)
return;
- flags &= ~(resetContext | resetAllContexts);
+ reset &= ~(resetContext | resetAllContexts);
} else {
ctx = findContext(r);
}
static LogWriter vlog("H264WinDecoderContext");
+// Older MinGW lacks this definition
+#ifndef HAVE_VIDEO_PROCESSOR_MFT
+static GUID CLSID_VideoProcessorMFT = { 0x88753b26, 0x5b24, 0x49bd, { 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78, 0xc9, 0x82 } };
+#endif
+
bool H264WinDecoderContext::initCodec() {
os::AutoMutex lock(&mutex);
return false;
}
- GUID CLSID_VideoProcessorMFT = { 0x88753b26, 0x5b24, 0x49bd, { 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78, 0xc9, 0x82 } };
if (FAILED(CoCreateInstance(CLSID_VideoProcessorMFT, nullptr, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&converter)))
{
vlog.error("Cannot create MediaFoundation Video Processor (available only on Windows 8+). Trying ColorConvert DMO.");
vlog.debug("Frame converted to RGB");
BYTE* out;
- DWORD len;
- converted_buffer->Lock(&out, nullptr, &len);
+ DWORD buflen;
+ converted_buffer->Lock(&out, nullptr, &buflen);
pb->imageRect(rect, out + offset_y * stride + offset_x * 4, (int)stride / 4);
converted_buffer->Unlock();
}
if (available == 0) \
{ \
if (length == 0) return; \
- byte = *buffer++; \
+ byte_ = *buffer++; \
length--; \
available = 8; \
} \
- bit = (byte >> --available) & 1; \
+ bit = (byte_ >> --available) & 1; \
} while (0)
#define GET_BITS(n, var) do { \
var = 0; \
- for (int i = n-1; i >= 0; i--) \
+ for (int b = n-1; b >= 0; b--) \
{ \
unsigned bit; \
GET_BIT(bit); \
- var |= bit << i; \
+ var |= bit << b; \
} \
} while (0)
length--;
int available = 0;
- uint8_t byte = 0;
+ uint8_t byte_ = 0;
unsigned profile_idc;
unsigned seq_parameter_set_id;
if (x + w > 16 || y + h > 16) {
throw rfb::Exception("HEXTILE_DECODE: Hextile out of bounds");
}
- T* ptr = buf + y * t.width() + x;
+ ptr = buf + y * t.width() + x;
int rowAdd = t.width() - w;
while (h-- > 0) {
- int len = w;
+ len = w;
while (len-- > 0) *ptr++ = fg;
ptr += rowAdd;
}
"ratios by the cost of using more CPU time",
true);
-HextileEncoder::HextileEncoder(SConnection* conn) :
- Encoder(conn, encodingHextile, EncoderPlain)
+HextileEncoder::HextileEncoder(SConnection* conn_) :
+ Encoder(conn_, encodingHextile, EncoderPlain)
{
}
using namespace rfb;
-RREEncoder::RREEncoder(SConnection* conn) :
- Encoder(conn, encodingRRE, EncoderPlain)
+RREEncoder::RREEncoder(SConnection* conn_) :
+ Encoder(conn_, encodingRRE, EncoderPlain)
{
}
using namespace rfb;
-RawEncoder::RawEncoder(SConnection* conn) :
- Encoder(conn, encodingRaw, EncoderPlain)
+RawEncoder::RawEncoder(SConnection* conn_) :
+ Encoder(conn_, encodingRaw, EncoderPlain)
{
}
static LogWriter vlog("SConnection");
-SConnection::SConnection(AccessRights accessRights)
+SConnection::SConnection(AccessRights accessRights_)
: readyForSetColourMapEntries(false), is(nullptr), os(nullptr),
reader_(nullptr), writer_(nullptr), ssecurity(nullptr),
authFailureTimer(this, &SConnection::handleAuthFailureTimeout),
state_(RFBSTATE_UNINITIALISED), preferredEncoding(encodingRaw),
- accessRights(accessRights), hasRemoteClipboard(false),
+ accessRights(accessRights_), hasRemoteClipboard(false),
hasLocalClipboard(false),
unsolicitedClipboardAttempt(false)
{
// FIXME: This conversion magic should be in SMsgWriter
std::string filtered(convertCRLF(data));
size_t sizes[1] = { filtered.size() + 1 };
- const uint8_t* data[1] = { (const uint8_t*)filtered.c_str() };
+ const uint8_t* datas[1] = { (const uint8_t*)filtered.c_str() };
if (unsolicitedClipboardAttempt) {
unsolicitedClipboardAttempt = false;
}
}
- writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, data);
+ writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, datas);
} else {
writer()->writeServerCutText(data);
}
class SSecurityNone : public SSecurity {
public:
- SSecurityNone(SConnection* sc) : SSecurity(sc) {}
+ SSecurityNone(SConnection* sc_) : SSecurity(sc_) {}
bool processMsg() override { return true; }
int getType() const override {return secTypeNone;}
const char* getUserName() const override {return nullptr;}
return false;
}
-SSecurityPlain::SSecurityPlain(SConnection* sc) : SSecurity(sc)
+SSecurityPlain::SSecurityPlain(SConnection* sc_) : SSecurity(sc_)
{
#ifdef WIN32
valid = new WinPasswdValidator();
("RequireUsername", "Require username for the RSA-AES security types",
false, ConfServer);
-SSecurityRSAAES::SSecurityRSAAES(SConnection* sc, uint32_t _secType,
+SSecurityRSAAES::SSecurityRSAAES(SConnection* sc_, uint32_t _secType,
int _keySize, bool _isAllEncrypted)
- : SSecurity(sc), state(SendPublicKey),
+ : SSecurity(sc_), state(SendPublicKey),
keySize(_keySize), isAllEncrypted(_isAllEncrypted), secType(_secType),
serverKey(), clientKey(),
serverKeyN(nullptr), serverKeyE(nullptr),
using namespace rfb;
-SSecurityStack::SSecurityStack(SConnection* sc, int Type,
+SSecurityStack::SSecurityStack(SConnection* sc_, int Type,
SSecurity* s0, SSecurity* s1)
- : SSecurity(sc), state(0), state0(s0), state1(s1), type(Type)
+ : SSecurity(sc_), state(0), state0(s0), state1(s1), type(Type)
{
}
static LogWriter vlog("TLS");
-SSecurityTLS::SSecurityTLS(SConnection* sc, bool _anon)
- : SSecurity(sc), session(nullptr), anon_cred(nullptr),
+SSecurityTLS::SSecurityTLS(SConnection* sc_, bool _anon)
+ : SSecurity(sc_), session(nullptr), anon_cred(nullptr),
cert_cred(nullptr), anon(_anon), tlsis(nullptr), tlsos(nullptr),
rawis(nullptr), rawos(nullptr)
{
static LogWriter vlog("SVeNCrypt");
-SSecurityVeNCrypt::SSecurityVeNCrypt(SConnection* sc, SecurityServer *sec)
- : SSecurity(sc), security(sec)
+SSecurityVeNCrypt::SSecurityVeNCrypt(SConnection* sc_,
+ SecurityServer *sec)
+ : SSecurity(sc_), security(sec)
{
ssecurity = nullptr;
haveSentVersion = false;
("Password", "Obfuscated binary encoding of the password which clients must supply to "
"access the server", &SSecurityVncAuth::vncAuthPasswdFile);
-SSecurityVncAuth::SSecurityVncAuth(SConnection* sc)
- : SSecurity(sc), sentChallenge(false),
+SSecurityVncAuth::SSecurityVncAuth(SConnection* sc_)
+ : SSecurity(sc_), sentChallenge(false),
pg(&vncAuthPasswd), accessRights(AccessNone)
{
}
throw AuthFailureException();
}
-VncAuthPasswdParameter::VncAuthPasswdParameter(const char* name,
+VncAuthPasswdParameter::VncAuthPasswdParameter(const char* name_,
const char* desc,
StringParameter* passwdFile_)
-: BinaryParameter(name, desc, nullptr, 0, ConfServer),
+: BinaryParameter(name_, desc, nullptr, 0, ConfServer),
passwdFile(passwdFile_)
{
}
{ 9, 9, 9 } // 9
};
-TightEncoder::TightEncoder(SConnection* conn) :
- Encoder(conn, encodingTight, EncoderPlain, 256)
+TightEncoder::TightEncoder(SConnection* conn_) :
+ Encoder(conn_, encodingTight, EncoderPlain, 256)
{
setCompressLevel(-1);
}
};
-TightJPEGEncoder::TightJPEGEncoder(SConnection* conn) :
- Encoder(conn, encodingTight,
+TightJPEGEncoder::TightJPEGEncoder(SConnection* conn_) :
+ Encoder(conn_, encodingTight,
(EncoderFlags)(EncoderUseNativePF | EncoderLossy), -1, 9),
qualityLevel(-1), fineQuality(-1), fineSubsampling(subsampleUndefined)
{
handleClipboardAnnounce(*ci, false);
clipboardRequestors.remove(*ci);
- std::string name((*ci)->getPeerEndpoint());
+ std::string peer((*ci)->getPeerEndpoint());
// - Delete the per-Socket resources
delete *ci;
clients.remove(*ci);
- connectionsLog.status("closed: %s", name.c_str());
+ connectionsLog.status("closed: %s", peer.c_str());
// - Check that the desktop object is still required
if (authClientCount() == 0)
IntParameter zlibLevel("ZlibLevel","[DEPRECATED] Zlib compression level",-1);
-ZRLEEncoder::ZRLEEncoder(SConnection* conn)
- : Encoder(conn, encodingZRLE, EncoderPlain, 127),
+ZRLEEncoder::ZRLEEncoder(SConnection* conn_)
+ : Encoder(conn_, encodingZRLE, EncoderPlain, 127),
zos(nullptr, 2), mos(129*1024)
{
if (zlibLevel != -1) {
{
}
-Manager::Manager(class rfb::SConnection *conn) :
- EncodeManager(conn)
+Manager::Manager(class rfb::SConnection *conn_) :
+ EncodeManager(conn_)
{
}
return s;
}
-static void sort(double *array, int count)
+static void sort(double *array, int len)
{
bool sorted;
int i;
do {
sorted = true;
- for (i = 1; i < count; i++) {
+ for (i = 1; i < len; i++) {
if (array[i-1] > array[i]) {
double d;
d = array[i];
try {
pf = new rfb::PixelFormat(b, d, e, t, rm, gm, bm, rs, gs, bs);
- } catch(rfb::Exception &e) {
+ } catch(rfb::Exception&) {
if (should_fail)
printf("OK");
else
class TXDialog : public TXWindow, public TXDeleteWindowCallback {
public:
- TXDialog(Display* dpy, int width, int height, const char* name,
+ TXDialog(Display* dpy_, int width, int height, const char* name,
bool modal_=false)
- : TXWindow(dpy, width, height), done(false), ok(false), modal(modal_)
+ : TXWindow(dpy_, width, height), done(false), ok(false), modal(modal_)
{
toplevel(name, this);
resize(width, height);
#include "QueryConnectDialog.h"
#include "vncExt.h"
-QueryConnectDialog::QueryConnectDialog(Display* dpy,
+QueryConnectDialog::QueryConnectDialog(Display* dpy_,
const char* address_,
const char* user_,
int timeout_,
QueryResultCallback* cb)
- : TXDialog(dpy, 300, 100, "VNC Server : Accept Connection?"),
+ : TXDialog(dpy_, 300, 100, "VNC Server : Accept Connection?"),
addressLbl(dpy, "Host:",this),
address(dpy, address_, this),
userLbl(dpy, "User:", this),
Display* dpy;
int vncExtEventBase, vncExtErrorBase;
-static bool getBoolParam(Display* dpy, const char* param) {
+static bool getBoolParam(Display* dpy_, const char* param) {
char* data;
int len;
- if (XVncExtGetParam(dpy, param, &data, &len)) {
+ if (XVncExtGetParam(dpy_, param, &data, &len)) {
if (strcmp(data,"1") == 0) return true;
}
return false;
public TXCheckboxCallback,
public QueryResultCallback {
public:
- VncConfigWindow(Display* dpy)
- : TXWindow(dpy, 300, 100),
- acceptClipboard(dpy, "Accept clipboard from viewers", this, false, this),
- setPrimaryCB(dpy, "Also set primary selection", this, false, this),
- sendClipboard(dpy, "Send clipboard to viewers", this, false, this),
- sendPrimaryCB(dpy, "Send primary selection to viewers", this,false,this),
+ VncConfigWindow(Display* dpy_)
+ : TXWindow(dpy_, 300, 100),
+ acceptClipboard(dpy_, "Accept clipboard from viewers", this, false, this),
+ setPrimaryCB(dpy_, "Also set primary selection", this, false, this),
+ sendClipboard(dpy_, "Send clipboard to viewers", this, false, this),
+ sendPrimaryCB(dpy_, "Send primary selection to viewers", this,false,this),
queryConnectDialog(nullptr)
{
int y = yPad;
} else if (strcmp(argv[i], "-list") == 0) {
int nParams;
char** list = XVncExtListParams(dpy, &nParams);
- for (int i = 0; i < nParams; i++) {
- printf("%s\n",list[i]);
+ for (int n = 0; n < nParams; n++) {
+ printf("%s\n",list[n]);
}
XVncExtFreeParamList(list);
} else if (strcmp(argv[i], "-set") == 0) {
XGetWindowProperty(fl_display, fl_xid(this), net_wm_state, 0, 1024, False, XA_ATOM, &type, &format, &nitems, &remain, (unsigned char**)&atoms);
- for (unsigned long i = 0;i < nitems;i++) {
- if ((atoms[i] == net_wm_state_maximized_vert) ||
- (atoms[i] == net_wm_state_maximized_horz)) {
+ for (unsigned long n = 0;n < nitems;n++) {
+ if ((atoms[n] == net_wm_state_maximized_vert) ||
+ (atoms[n] == net_wm_state_maximized_horz)) {
maximized = true;
break;
}
windowRect.setXYWH(x(), y(), w(), h());
bool foundEnclosedScreen = false;
- for (int i = 0; i < Fl::screen_count(); i++) {
- Fl::screen_xywh(sx, sy, sw, sh, i);
+ for (int idx = 0; idx < Fl::screen_count(); idx++) {
+ Fl::screen_xywh(sx, sy, sw, sh, idx);
// The screen with the smallest index that are enclosed by
// the viewport will be used for showing the overlay.
}
if (resize_req) {
- for (int i = 0;i < Fl::screen_count();i++) {
+ for (int idx = 0;idx < Fl::screen_count();idx++) {
int sx, sy, sw, sh;
- Fl::screen_xywh(sx, sy, sw, sh, i);
+ Fl::screen_xywh(sx, sy, sw, sh, idx);
// We can't trust x and y if the window isn't mapped as the
// window manager might adjust those numbers
std::set<int> selected = fullScreenSelectedMonitors.getParam();
monitors.insert(selected.begin(), selected.end());
} else {
- for (int i = 0; i < Fl::screen_count(); i++) {
- monitors.insert(i);
- }
+ for (int idx = 0; idx < Fl::screen_count(); idx++)
+ monitors.insert(idx);
}
// If no monitors were found in the selected monitors case, we want
layout.begin()->dimensions.br.x = width;
layout.begin()->dimensions.br.y = height;
} else {
- int i;
uint32_t id;
int sx, sy, sw, sh;
rfb::Rect viewport_rect, screen_rect;
// FIXME: We should really track screens better so we can handle
// a resized one.
//
- for (i = 0;i < Fl::screen_count();i++) {
- Fl::screen_xywh(sx, sy, sw, sh, i);
+ for (int idx = 0;idx < Fl::screen_count();idx++) {
+ Fl::screen_xywh(sx, sy, sw, sh, idx);
// Check that the screen is fully inside the framebuffer
screen_rect.setXYWH(sx, sy, sw, sh);
return indices;
}
-bool MonitorIndicesParameter::setParam(const char* value)
+bool MonitorIndicesParameter::setParam(const char* v)
{
std::set<int> indices;
- if (!parseIndices(value, &indices, true)) {
+ if (!parseIndices(v, &indices, true)) {
vlog.error(_("Invalid configuration specified for %s"), name);
return false;
}
vlog.error(_("Monitor index %d does not exist"), index);
}
- return StringParameter::setParam(value);
+ return StringParameter::setParam(v);
}
bool MonitorIndicesParameter::setParam(std::set<int> indices)
MonitorIndicesParameter(const char* name_, const char* desc_, const char* v);
std::set<int> getParam();
bool setParam(std::set<int> indices);
- bool setParam(const char* value) override;
+ bool setParam(const char* v) override;
private:
typedef struct {
int x, y, w, h;
menuKeyChoice->value(0);
menuKeyBuf = menuKey;
- for (int i = 0; i < getMenuKeySymbolCount(); i++)
- if (!strcmp(getMenuKeySymbols()[i].name, menuKeyBuf))
- menuKeyChoice->value(i + 1);
+ for (int idx = 0; idx < getMenuKeySymbolCount(); idx++)
+ if (!strcmp(getMenuKeySymbols()[idx].name, menuKeyBuf))
+ menuKeyChoice->value(idx + 1);
/* Display */
if (!fullScreen) {
menuKeyChoice = new Fl_Choice(LBLLEFT(tx, ty, 150, CHOICE_HEIGHT, _("Menu key")));
fltk_menu_add(menuKeyChoice, _("None"), 0, nullptr, nullptr, FL_MENU_DIVIDER);
- for (int i = 0; i < getMenuKeySymbolCount(); i++)
- fltk_menu_add(menuKeyChoice, getMenuKeySymbols()[i].name, 0, nullptr, nullptr, 0);
+ for (int idx = 0; idx < getMenuKeySymbolCount(); idx++)
+ fltk_menu_add(menuKeyChoice, getMenuKeySymbols()[idx].name, 0, nullptr, nullptr, 0);
ty += CHOICE_HEIGHT + TIGHT_MARGIN;
}
filepath, strerror(errno));
// Save the last X elements to the config file.
- for(size_t i=0; i < serverHistory.size() && i <= SERVER_HISTORY_SIZE; i++)
- fprintf(f, "%s\n", serverHistory[i].c_str());
+ for(size_t idx=0; idx < serverHistory.size() && idx <= SERVER_HISTORY_SIZE; idx++)
+ fprintf(f, "%s\n", serverHistory[idx].c_str());
fclose(f);
}
void clear(unsigned char r, unsigned char g, unsigned char b, unsigned char a=255);
- void draw(int src_x, int src_y, int x, int y, int w, int h);
- void draw(Surface* dst, int src_x, int src_y, int x, int y, int w, int h);
+ void draw(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h);
+ void draw(Surface* dst, int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h);
- void blend(int src_x, int src_y, int x, int y, int w, int h, int a=255);
- void blend(Surface* dst, int src_x, int src_y, int x, int y, int w, int h, int a=255);
+ void blend(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h, int a=255);
+ void blend(Surface* dst, int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h, int a=255);
protected:
void alloc();
}
}
-void Surface::draw(int src_x, int src_y, int x, int y, int w, int h)
+void Surface::draw(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h)
{
CGColorSpaceRef lut;
CGContextConcatCTM(fl_gc, CGAffineTransformInvert(CGContextGetCTM(fl_gc)));
// macOS Coordinates are from bottom left, not top left
- y = Fl_Window::current()->h() - (y + h);
+ dst_y = Fl_Window::current()->h() - (dst_y + dst_h);
lut = cocoa_win_color_space(Fl_Window::current());
render(fl_gc, lut, data, kCGBlendModeCopy, 1.0,
- src_x, src_y, width(), height(), x, y, w, h);
+ src_x, src_y, width(), height(), dst_x, dst_y, dst_w, dst_h);
CGColorSpaceRelease(lut);
CGContextRestoreGState(fl_gc);
}
-void Surface::draw(Surface* dst, int src_x, int src_y, int x, int y, int w, int h)
+void Surface::draw(Surface* dst, int src_x, int src_y,
+ int dst_x, int dst_y, int dst_w, int dst_h)
{
CGContextRef bitmap;
bitmap = make_bitmap(dst->width(), dst->height(), dst->data);
// macOS Coordinates are from bottom left, not top left
- y = dst->height() - (y + h);
+ dst_y = dst->height() - (dst_y + dst_h);
render(bitmap, srgb, data, kCGBlendModeCopy, 1.0,
- src_x, src_y, width(), height(), x, y, w, h);
+ src_x, src_y, width(), height(), dst_x, dst_y, dst_w, dst_h);
CGContextRelease(bitmap);
}
-void Surface::blend(int src_x, int src_y, int x, int y, int w, int h, int a)
+void Surface::blend(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h, int a)
{
CGColorSpaceRef lut;
CGContextConcatCTM(fl_gc, CGAffineTransformInvert(CGContextGetCTM(fl_gc)));
// macOS Coordinates are from bottom left, not top left
- y = Fl_Window::current()->h() - (y + h);
+ dst_y = Fl_Window::current()->h() - (dst_y + dst_h);
lut = cocoa_win_color_space(Fl_Window::current());
render(fl_gc, lut, data, kCGBlendModeNormal, (CGFloat)a/255.0,
- src_x, src_y, width(), height(), x, y, w, h);
+ src_x, src_y, width(), height(), dst_x, dst_y, dst_w, dst_h);
CGColorSpaceRelease(lut);
CGContextRestoreGState(fl_gc);
}
-void Surface::blend(Surface* dst, int src_x, int src_y, int x, int y, int w, int h, int a)
+void Surface::blend(Surface* dst, int src_x, int src_y,
+ int dst_x, int dst_y, int dst_w, int dst_h, int a)
{
CGContextRef bitmap;
bitmap = make_bitmap(dst->width(), dst->height(), dst->data);
// macOS Coordinates are from bottom left, not top left
- y = dst->height() - (y + h);
+ dst_y = dst->height() - (dst_y + dst_h);
render(bitmap, srgb, data, kCGBlendModeNormal, (CGFloat)a/255.0,
- src_x, src_y, width(), height(), x, y, w, h);
+ src_x, src_y, width(), height(), dst_x, dst_y, dst_w, dst_h);
CGContextRelease(bitmap);
}
}
}
-void Surface::draw(int src_x, int src_y, int x, int y, int w, int h)
+void Surface::draw(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h)
{
HDC dc;
if (!SelectObject(dc, bitmap))
throw rdr::SystemException("SelectObject", GetLastError());
- if (!BitBlt(fl_gc, x, y, w, h, dc, src_x, src_y, SRCCOPY)) {
+ if (!BitBlt(fl_gc, dst_x, dst_y, dst_w, dst_h,
+ dc, src_x, src_y, SRCCOPY)) {
// If the desktop we're rendering to is inactive (like when the screen
// is locked or the UAC is active), then GDI calls will randomly fail.
// This is completely undocumented so we have no idea how best to deal
DeleteDC(dc);
}
-void Surface::draw(Surface* dst, int src_x, int src_y, int x, int y, int w, int h)
+void Surface::draw(Surface* dst, int src_x, int src_y,
+ int dst_x, int dst_y, int dst_w, int dst_h)
{
HDC origdc, dstdc;
origdc = fl_gc;
fl_gc = dstdc;
- draw(src_x, src_y, x, y, w, h);
+ draw(src_x, src_y, dst_x, dst_y, dst_w, dst_h);
fl_gc = origdc;
DeleteDC(dstdc);
}
void Surface::blend(int /*src_x*/, int /*src_y*/,
- int /*x*/, int /*y*/, int /*w*/, int /*h*/,
+ int /*dst_x*/, int /*dst_y*/,
+ int /*dst_w*/, int /*dst_h*/,
int /*a*/)
{
// Compositing doesn't work properly for window DC:s
assert(false);
}
-void Surface::blend(Surface* dst, int src_x, int src_y, int x, int y, int w, int h, int a)
+void Surface::blend(Surface* dst, int src_x, int src_y,
+ int dst_x, int dst_y, int dst_w, int dst_h, int a)
{
HDC dstdc, srcdc;
BLENDFUNCTION blend;
blend.SourceConstantAlpha = a;
blend.AlphaFormat = AC_SRC_ALPHA;
- if (!AlphaBlend(dstdc, x, y, w, h, srcdc, src_x, src_y, w, h, blend)) {
+ if (!AlphaBlend(dstdc, dst_x, dst_y, dst_w, dst_h,
+ srcdc, src_x, src_y, dst_w, dst_h, blend)) {
// If the desktop we're rendering to is inactive (like when the screen
// is locked or the UAC is active), then GDI calls will randomly fail.
// This is completely undocumented so we have no idea how best to deal
0, 0, width(), height());
}
-void Surface::draw(int src_x, int src_y, int x, int y, int w, int h)
+void Surface::draw(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h)
{
Picture winPict;
winPict = XRenderCreatePicture(fl_display, fl_window, visFormat, 0, nullptr);
XRenderComposite(fl_display, PictOpSrc, picture, None, winPict,
- src_x, src_y, 0, 0, x, y, w, h);
+ src_x, src_y, 0, 0, dst_x, dst_y, dst_w, dst_h);
XRenderFreePicture(fl_display, winPict);
}
-void Surface::draw(Surface* dst, int src_x, int src_y, int x, int y, int w, int h)
+void Surface::draw(Surface* dst, int src_x, int src_y,
+ int dst_x, int dst_y, int dst_w, int dst_h)
{
XRenderComposite(fl_display, PictOpSrc, picture, None, dst->picture,
- src_x, src_y, 0, 0, x, y, w, h);
+ src_x, src_y, 0, 0, dst_x, dst_y, dst_w, dst_h);
}
static Picture alpha_mask(int a)
return pict;
}
-void Surface::blend(int src_x, int src_y, int x, int y, int w, int h, int a)
+void Surface::blend(int src_x, int src_y, int dst_x, int dst_y,
+ int dst_w, int dst_h, int a)
{
Picture winPict, alpha;
winPict = XRenderCreatePicture(fl_display, fl_window, visFormat, 0, nullptr);
alpha = alpha_mask(a);
XRenderComposite(fl_display, PictOpOver, picture, alpha, winPict,
- src_x, src_y, 0, 0, x, y, w, h);
+ src_x, src_y, 0, 0, dst_x, dst_y, dst_w, dst_h);
XRenderFreePicture(fl_display, winPict);
if (alpha != None)
XRenderFreePicture(fl_display, alpha);
}
-void Surface::blend(Surface* dst, int src_x, int src_y, int x, int y, int w, int h, int a)
+void Surface::blend(Surface* dst, int src_x, int src_y,
+ int dst_x, int dst_y, int dst_w, int dst_h, int a)
{
Picture alpha;
alpha = alpha_mask(a);
XRenderComposite(fl_display, PictOpOver, picture, alpha, dst->picture,
- src_x, src_y, 0, 0, x, y, w, h);
+ src_x, src_y, 0, 0, dst_x, dst_y, dst_w, dst_h);
if (alpha != None)
XRenderFreePicture(fl_display, alpha);
}
{
}
-void UserDialog::getUserPasswd(bool secure, std::string* user,
+void UserDialog::getUserPasswd(bool secure_, std::string* user,
std::string* password)
{
const char *passwordFileName(passwordFile);
banner = new Fl_Box(0, 0, win->w(), 20);
banner->align(FL_ALIGN_CENTER|FL_ALIGN_INSIDE|FL_ALIGN_IMAGE_NEXT_TO_TEXT);
banner->box(FL_FLAT_BOX);
- if (secure) {
+ if (secure_) {
banner->label(_("This connection is secure"));
banner->color(FL_GREEN);
banner->image(secure_icon);
Fl::copy(data, len, 1);
}
-void Viewport::setLEDState(unsigned int state)
+void Viewport::setLEDState(unsigned int ledState)
{
- vlog.debug("Got server LED state: 0x%08x", state);
+ vlog.debug("Got server LED state: 0x%08x", ledState);
// The first message is just considered to be the server announcing
// support for this extension. We will push our state to sync up the
memset(input, 0, sizeof(input));
count = 0;
- if (!!(state & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
+ if (!!(ledState & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
input[count].type = input[count+1].type = INPUT_KEYBOARD;
input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
count += 2;
}
- if (!!(state & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
+ if (!!(ledState & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
input[count].type = input[count+1].type = INPUT_KEYBOARD;
input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
count += 2;
}
- if (!!(state & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
+ if (!!(ledState & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
input[count].type = input[count+1].type = INPUT_KEYBOARD;
input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
#elif defined(__APPLE__)
int ret;
- ret = cocoa_set_caps_lock_state(state & ledCapsLock);
+ ret = cocoa_set_caps_lock_state(ledState & ledCapsLock);
if (ret != 0) {
vlog.error(_("Failed to update keyboard LED state: %d"), ret);
return;
}
- ret = cocoa_set_num_lock_state(state & ledNumLock);
+ ret = cocoa_set_num_lock_state(ledState & ledNumLock);
if (ret != 0) {
vlog.error(_("Failed to update keyboard LED state: %d"), ret);
return;
affect = values = 0;
affect |= LockMask;
- if (state & ledCapsLock)
+ if (ledState & ledCapsLock)
values |= LockMask;
mask = getModifierMask(XK_Num_Lock);
affect |= mask;
- if (state & ledNumLock)
+ if (ledState & ledNumLock)
values |= mask;
mask = getModifierMask(XK_Scroll_Lock);
affect |= mask;
- if (state & ledScrollLock)
+ if (ledState & ledScrollLock)
values |= mask;
ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
void Viewport::pushLEDState()
{
- unsigned int state;
+ unsigned int ledState;
// Server support?
if (cc->server.ledState() == ledUnknown)
return;
- state = 0;
+ ledState = 0;
#if defined(WIN32)
if (GetKeyState(VK_CAPITAL) & 0x1)
- state |= ledCapsLock;
+ ledState |= ledCapsLock;
if (GetKeyState(VK_NUMLOCK) & 0x1)
- state |= ledNumLock;
+ ledState |= ledNumLock;
if (GetKeyState(VK_SCROLL) & 0x1)
- state |= ledScrollLock;
+ ledState |= ledScrollLock;
#elif defined(__APPLE__)
int ret;
bool on;
return;
}
if (on)
- state |= ledCapsLock;
+ ledState |= ledCapsLock;
ret = cocoa_get_num_lock_state(&on);
if (ret != 0) {
return;
}
if (on)
- state |= ledNumLock;
+ ledState |= ledNumLock;
// No support for Scroll Lock //
- state |= (cc->server.ledState() & ledScrollLock);
+ ledState |= (cc->server.ledState() & ledScrollLock);
#else
unsigned int mask;
}
if (xkbState.locked_mods & LockMask)
- state |= ledCapsLock;
+ ledState |= ledCapsLock;
mask = getModifierMask(XK_Num_Lock);
if (xkbState.locked_mods & mask)
- state |= ledNumLock;
+ ledState |= ledNumLock;
mask = getModifierMask(XK_Scroll_Lock);
if (xkbState.locked_mods & mask)
- state |= ledScrollLock;
+ ledState |= ledScrollLock;
#endif
- if ((state & ledCapsLock) != (cc->server.ledState() & ledCapsLock)) {
+ if ((ledState & ledCapsLock) != (cc->server.ledState() & ledCapsLock)) {
vlog.debug("Inserting fake CapsLock to get in sync with server");
handleKeyPress(0x3a, XK_Caps_Lock);
handleKeyRelease(0x3a);
}
- if ((state & ledNumLock) != (cc->server.ledState() & ledNumLock)) {
+ if ((ledState & ledNumLock) != (cc->server.ledState() & ledNumLock)) {
vlog.debug("Inserting fake NumLock to get in sync with server");
handleKeyPress(0x45, XK_Num_Lock);
handleKeyRelease(0x45);
}
- if ((state & ledScrollLock) != (cc->server.ledState() & ledScrollLock)) {
+ if ((ledState & ledScrollLock) != (cc->server.ledState() & ledScrollLock)) {
vlog.debug("Inserting fake ScrollLock to get in sync with server");
handleKeyPress(0x46, XK_Scroll_Lock);
handleKeyRelease(0x46);
static const unsigned SINGLE_PAN_THRESHOLD = 50;
-Win32TouchHandler::Win32TouchHandler(HWND hWnd) :
- hWnd(hWnd), gesturesConfigured(false), gestureActive(false),
+Win32TouchHandler::Win32TouchHandler(HWND hWnd_) :
+ hWnd(hWnd_), gesturesConfigured(false), gestureActive(false),
ignoringGesture(false), fakeButtonMask(0)
{
// If window is registered as touch we can not receive gestures,
static bool grabbed = false;
-XInputTouchHandler::XInputTouchHandler(Window wnd)
- : wnd(wnd), fakeStateMask(0)
+XInputTouchHandler::XInputTouchHandler(Window wnd_)
+ : wnd(wnd_), fakeStateMask(0)
{
XIEventMask eventmask;
unsigned char flags[XIMaskLen(XI_LASTEVENT)] = { 0 };
{
Window root, child;
int rootX, rootY;
- XkbStateRec state;
+ XkbStateRec xkbState;
// We don't have a real event to steal things from, so we'll have
// to fake these events based on the current state of things
src.eventX,
src.eventY,
&rootX, &rootY, &child);
- XkbGetState(fl_display, XkbUseCoreKbd, &state);
+ XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
// XButtonEvent and XMotionEvent are almost identical, so we
// don't have to care which it is for these fields
dst->xbutton.y = src.eventY;
dst->xbutton.x_root = rootX;
dst->xbutton.y_root = rootY;
- dst->xbutton.state = state.mods;
- dst->xbutton.state |= ((state.ptr_buttons >> 1) & 0x1f) << 8;
+ dst->xbutton.state = xkbState.mods;
+ dst->xbutton.state |= ((xkbState.ptr_buttons >> 1) & 0x1f) << 8;
dst->xbutton.same_screen = True;
}
Window root, child;
int rootX, rootY;
- XkbStateRec state;
+ XkbStateRec xkbState;
int modmask;
origEvent.eventX,
origEvent.eventY,
&rootX, &rootY, &child);
- XkbGetState(fl_display, XkbUseCoreKbd, &state);
+ XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
KeyCode kc = XKeysymToKeycode(fl_display, keysym);
fakeEvent.xkey.y = origEvent.eventY;
fakeEvent.xkey.x_root = rootX;
fakeEvent.xkey.y_root = rootY;
- fakeEvent.xkey.state = state.mods;
- fakeEvent.xkey.state |= ((state.ptr_buttons >> 1) & 0x1f) << 8;
+ fakeEvent.xkey.state = xkbState.mods;
+ fakeEvent.xkey.state |= ((xkbState.ptr_buttons >> 1) & 0x1f) << 8;
fakeEvent.xkey.same_screen = True;
// Apply our fake mask
}
static void
-potentiallyLoadConfigurationFile(char *vncServerName)
+potentiallyLoadConfigurationFile(const char *filename)
{
- const bool hasPathSeparator = (strchr(vncServerName, '/') != nullptr ||
- (strchr(vncServerName, '\\')) != nullptr);
+ const bool hasPathSeparator = (strchr(filename, '/') != nullptr ||
+ (strchr(filename, '\\')) != nullptr);
if (hasPathSeparator) {
#ifndef WIN32
struct stat sb;
// This might be a UNIX socket, we need to check
- if (stat(vncServerName, &sb) == -1) {
+ if (stat(filename, &sb) == -1) {
// Some access problem; let loadViewerParameters() deal with it...
} else {
if ((sb.st_mode & S_IFMT) == S_IFSOCK)
try {
const char* newServerName;
- newServerName = loadViewerParameters(vncServerName);
+ newServerName = loadViewerParameters(filename);
// This might be empty, but we still need to clear it so we
// don't try to connect to the filename
strncpy(vncServerName, newServerName, VNCSERVERNAMELEN-1);
uint8_t* rwbuffer = buffer.data();
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
- int byte = y * maskInfo.bmWidthBytes + x / 8;
+ int byte_ = y * maskInfo.bmWidthBytes + x / 8;
int bit = 7 - x % 8;
- if (!(andMask[byte] & (1 << bit))) {
+ if (!(andMask[byte_] & (1 << bit))) {
// Valid pixel, so make it opaque
rwbuffer[3] = 0xff;
// Black or white?
- if (xorMask[byte] & (1 << bit))
+ if (xorMask[byte_] & (1 << bit))
rwbuffer[0] = rwbuffer[1] = rwbuffer[2] = 0xff;
else
rwbuffer[0] = rwbuffer[1] = rwbuffer[2] = 0;
- } else if (xorMask[byte] & (1 << bit)) {
+ } else if (xorMask[byte_] & (1 << bit)) {
// Replace any XORed pixels with black, because RFB doesn't support
// XORing of cursors. XORing is used for the I-beam cursor, which is most
// often used over a white background, but also sometimes over a black
}
-PropSheetPage::PropSheetPage(HINSTANCE inst, const char* id) : Dialog(inst), propSheet(nullptr) {
+PropSheetPage::PropSheetPage(HINSTANCE inst_, const char* id) : Dialog(inst_), propSheet(nullptr) {
page.dwSize = sizeof(page);
page.dwFlags = 0; // PSP_USECALLBACK;
page.hInstance = inst;
}
-bool PropSheet::showPropSheet(HWND owner, bool showApply, bool showCtxtHelp, bool capture) {
+bool PropSheet::showPropSheet(HWND owner_, bool showApply, bool showCtxtHelp, bool capture) {
if (alreadyShowing) return false;
alreadyShowing = true;
int count = pages.size();
header.dwSize = sizeof(PROPSHEETHEADER); // Requires comctl32.dll 4.71 or greater, ie IE 4 or later
header.dwFlags = PSH_MODELESS | (showApply ? 0 : PSH_NOAPPLYNOW) | (showCtxtHelp ? 0 : PSH_USECALLBACK);
header.pfnCallback = removeCtxtHelp;
- header.hwndParent = owner;
+ header.hwndParent = owner_;
header.hInstance = inst;
header.pszCaption = title.c_str();
header.nPages = count;
handle = (HWND)PropertySheet(&header);
if ((handle == nullptr) || (handle == (HWND)-1))
throw rdr::SystemException("PropertySheet failed", GetLastError());
- centerWindow(handle, owner);
+ centerWindow(handle, owner_);
plog.info("created %p", handle);
(void)capture;
} else {
#endif
try {
- if (owner)
- EnableWindow(owner, FALSE);
+ if (owner_)
+ EnableWindow(owner_, FALSE);
// Run the PropertySheet
MSG msg;
while (GetMessage(&msg, nullptr, 0, 0)) {
if (!PropSheet_GetCurrentPageHwnd(handle))
break;
}
- if (owner)
- EnableWindow(owner, TRUE);
+ if (owner_)
+ EnableWindow(owner_, TRUE);
} catch (...) {
- if (owner)
- EnableWindow(owner, TRUE);
+ if (owner_)
+ EnableWindow(owner_, TRUE);
throw;
}
#ifdef _DIALOG_CAPTURE
DWORD required = ExpandEnvironmentStrings(str.c_str(), nullptr, 0);
if (required==0)
throw rdr::SystemException("ExpandEnvironmentStrings", GetLastError());
- std::vector<char> result(required);
- length = ExpandEnvironmentStrings(str.c_str(), result.data(), required);
+ std::vector<char> expanded(required);
+ length = ExpandEnvironmentStrings(str.c_str(), expanded.data(), required);
if (required<length)
throw rdr::Exception("unable to expand environment strings");
- return result.data();
+ return expanded.data();
} else {
return "";
}
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
// - Add the service
- ServiceHandle service = CreateService(scm,
+ ServiceHandle handle = CreateService(scm,
name, display, SC_MANAGER_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_IGNORE,
cmdline.c_str(), nullptr, nullptr, nullptr, nullptr, nullptr);
- if (!service)
+ if (!handle)
throw rdr::SystemException("unable to create service", GetLastError());
// - Set a description
SERVICE_DESCRIPTION sdesc = {(LPTSTR)desc};
- ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &sdesc);
+ ChangeServiceConfig2(handle, SERVICE_CONFIG_DESCRIPTION, &sdesc);
// - Register the event log source
RegKey hk, hk2;
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
// - Create the service
- ServiceHandle service = OpenService(scm, name, SC_MANAGER_ALL_ACCESS);
- if (!service)
+ ServiceHandle handle = OpenService(scm, name, SC_MANAGER_ALL_ACCESS);
+ if (!handle)
throw rdr::SystemException("unable to locate the service", GetLastError());
- if (!DeleteService(service))
+ if (!DeleteService(handle))
throw rdr::SystemException("unable to remove the service", GetLastError());
// - Register the event log source
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
// - Locate the service
- ServiceHandle service = OpenService(scm, name, SERVICE_START);
- if (!service)
+ ServiceHandle handle = OpenService(scm, name, SERVICE_START);
+ if (!handle)
throw rdr::SystemException("unable to open the service", GetLastError());
// - Start the service
- if (!StartService(service, 0, nullptr))
+ if (!StartService(handle, 0, nullptr))
throw rdr::SystemException("unable to start the service", GetLastError());
Sleep(500);
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
// - Locate the service
- ServiceHandle service = OpenService(scm, name, SERVICE_STOP);
- if (!service)
+ ServiceHandle handle = OpenService(scm, name, SERVICE_STOP);
+ if (!handle)
throw rdr::SystemException("unable to open the service", GetLastError());
// - Start the service
SERVICE_STATUS status;
- if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
+ if (!ControlService(handle, SERVICE_CONTROL_STOP, &status))
throw rdr::SystemException("unable to stop the service", GetLastError());
Sleep(500);
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
// - Locate the service
- ServiceHandle service = OpenService(scm, name, SERVICE_INTERROGATE);
- if (!service)
+ ServiceHandle handle = OpenService(scm, name, SERVICE_INTERROGATE);
+ if (!handle)
throw rdr::SystemException("unable to open the service", GetLastError());
// - Get the service status
SERVICE_STATUS status;
- if (!ControlService(service, SERVICE_CONTROL_INTERROGATE, (SERVICE_STATUS*)&status))
+ if (!ControlService(handle, SERVICE_CONTROL_INTERROGATE, (SERVICE_STATUS*)&status))
throw rdr::SystemException("unable to query the service", GetLastError());
return status.dwCurrentState;
try {
// Process data from an active connection
- WSANETWORKEVENTS events;
+ WSANETWORKEVENTS network_events;
long eventMask;
// Fetch why this event notification triggered
- if (WSAEnumNetworkEvents(ci.sock->getFd(), event, &events) == SOCKET_ERROR)
+ if (WSAEnumNetworkEvents(ci.sock->getFd(), event, &network_events) == SOCKET_ERROR)
throw rdr::SystemException("unable to get WSAEnumNetworkEvents:%u", WSAGetLastError());
// Cancel event notification for this socket
// Call the socket server to process the event
- if (events.lNetworkEvents & FD_WRITE) {
+ if (network_events.lNetworkEvents & FD_WRITE) {
ci.server->processSocketWriteEvent(ci.sock);
if (ci.sock->isShutdown()) {
remSocket(ci.sock);
return;
}
}
- if (events.lNetworkEvents & (FD_READ | FD_CLOSE)) {
+ if (network_events.lNetworkEvents & (FD_READ | FD_CLOSE)) {
ci.server->processSocketReadEvent(ci.sock);
if (ci.sock->isShutdown()) {
remSocket(ci.sock);
freopen("CONOUT$","wb",stderr);
setbuf(stderr, nullptr);
initStdIOLoggers();
- LogWriter vlog("main");
logParams.setParam("*:stderr:100");
vlog.info("Starting vncconfig applet");
#endif
// - Set the address-changed handler for the RFB socket
rfbSock.setAddressChangeNotifier(this);
- DWORD result = 0;
+ int result = 0;
try {
vlog.debug("Entering message loop");
// - Run the server until we're told to quit
MSG msg;
- int result = 0;
while (runServer) {
result = sockMgr.getMessage(&msg, nullptr, 0, 0);
if (result < 0)
LPARAM l = MAKELONG((SHORT)rect->right, (SHORT)rect->bottom);
return NotifyHookOwner(WM_HK_RectangleChanged, w, l);
}
-bool NotifyCursor(HCURSOR cursor) {
- return NotifyHookOwner(WM_HK_CursorChanged, 0, (LPARAM)cursor);
+bool NotifyCursor(HCURSOR cursor_) {
+ return NotifyHookOwner(WM_HK_CursorChanged, 0, (LPARAM)cursor_);
}
void ProcessWindowMessage(UINT msg, HWND wnd, WPARAM wParam, LPARAM /*lParam*/) {
projects / tigervnc.git / commitdiff