#include "precomp.h" // // HOST.CPP // Hosting, local and remote // // Copyright(c) Microsoft 1997- // #define MLZ_FILE_ZONE ZONE_CORE // // HET_Init() // // Initialization for hosting // * window tracking // * capabilities // * host UI // BOOL HET_Init(void) { BOOL rc = FALSE; int property; UINT i; LOGFONT lf; DebugEntry(HET_Init); // // Initialize T.128 capabilities, whether we can host or not. // ZeroMemory(&g_cpcLocalCaps, sizeof(g_cpcLocalCaps)); g_cpcLocalCaps.header.numCapabilities = PROTCAPS_COUNT; // PROTCAPS_GENERAL // Check for compression setting (useful to debug protocol) // You can set CT_PKZIP (1) or none (0) instead of persistent PKZIP, // which is the default. // g_cpcLocalCaps.general.header.capID = CAPS_ID_GENERAL; g_cpcLocalCaps.general.header.capSize = sizeof(g_cpcLocalCaps.general); COM_ReadProfInt(DBG_INI_SECTION_NAME, GDC_INI_COMPRESSION, GCT_DEFAULT, &property); g_cpcLocalCaps.general.OS = CAPS_WINDOWS; g_cpcLocalCaps.general.OSVersion = (g_asWin95 ? CAPS_WINDOWS_95 : CAPS_WINDOWS_NT); g_cpcLocalCaps.general.typeFlags = 0; if (g_asOptions & AS_SERVICE) { g_cpcLocalCaps.general.typeFlags |= AS_SERVICE; } if (g_asOptions & AS_UNATTENDED) { g_cpcLocalCaps.general.typeFlags |= AS_UNATTENDED; } g_cpcLocalCaps.general.version = CAPS_VERSION_CURRENT; // // PROTCAPS_SCREEN // g_cpcLocalCaps.screen.header.capID = CAPS_ID_SCREEN; g_cpcLocalCaps.screen.header.capSize = sizeof(g_cpcLocalCaps.screen); g_cpcLocalCaps.screen.capsSupports1BPP = CAPS_UNSUPPORTED; g_cpcLocalCaps.screen.capsSupports4BPP = CAPS_SUPPORTED; g_cpcLocalCaps.screen.capsSupports8BPP = CAPS_SUPPORTED; g_cpcLocalCaps.screen.capsSupports24BPP = CAPS_SUPPORTED; g_cpcLocalCaps.screen.capsScreenWidth = (TSHR_UINT16)GetSystemMetrics(SM_CXSCREEN); g_cpcLocalCaps.screen.capsScreenHeight = (TSHR_UINT16)GetSystemMetrics(SM_CYSCREEN); g_cpcLocalCaps.screen.capsSupportsDesktopResize = CAPS_SUPPORTED; // // Set up the V1 and/or V2 Bitmap Compression capabilities. For the // V2.0 protocol, both are supported by default (supporting V1 // compression allows for negotiation down to V1 protocol systems), but // can be overidden in the INI file. // g_cpcLocalCaps.screen.capsBPP = (TSHR_UINT16)g_usrScreenBPP; // PROTCAPS_SC g_cpcLocalCaps.share.header.capID = CAPS_ID_SC; g_cpcLocalCaps.share.header.capSize = sizeof(g_cpcLocalCaps.share); g_cpcLocalCaps.share.gccID = 0; // PROTCAPS_CM g_cpcLocalCaps.cursor.header.capID = CAPS_ID_CM; g_cpcLocalCaps.cursor.header.capSize = sizeof(g_cpcLocalCaps.cursor); g_cpcLocalCaps.cursor.capsSupportsColorCursors = CAPS_SUPPORTED; g_cpcLocalCaps.cursor.capsCursorCacheSize = TSHR_CM_CACHE_ENTRIES; // PROTCAPS_PM g_cpcLocalCaps.palette.header.capID = CAPS_ID_PM; g_cpcLocalCaps.palette.header.capSize = sizeof(g_cpcLocalCaps.palette); g_cpcLocalCaps.palette.capsColorTableCacheSize = TSHR_PM_CACHE_ENTRIES; // // PROTCAPS_BITMAPCACHE // g_cpcLocalCaps.bitmaps.header.capID = CAPS_ID_BITMAPCACHE; g_cpcLocalCaps.bitmaps.header.capSize = sizeof(g_cpcLocalCaps.bitmaps); // // SEND BITMAP CACHE // // The cache is now more in line with what the display driver is doing. // The memory size for medium/large is the same. But large bitmaps are // 4x bigger, so there are 1/4 as many. The # of small bitmaps is the // same as the # of medium bitmaps. Since small bitmaps are 1/4 the // size, only 1/4 as much memory is used. // if (g_sbcEnabled) { UINT maxSendBPP; ASSERT(g_asbcShuntBuffers[SBC_MEDIUM_TILE_INDEX]); ASSERT(g_asbcShuntBuffers[SBC_LARGE_TILE_INDEX]); g_cpcLocalCaps.bitmaps.sender.capsSmallCacheNumEntries = (TSHR_UINT16)g_asbcShuntBuffers[SBC_MEDIUM_TILE_INDEX]->numEntries; g_cpcLocalCaps.bitmaps.sender.capsMediumCacheNumEntries = (TSHR_UINT16)g_asbcShuntBuffers[SBC_MEDIUM_TILE_INDEX]->numEntries; g_cpcLocalCaps.bitmaps.sender.capsLargeCacheNumEntries = (TSHR_UINT16)g_asbcShuntBuffers[SBC_LARGE_TILE_INDEX]->numEntries; if (g_usrScreenBPP >= 24) { maxSendBPP = 24; } else { maxSendBPP = 8; } g_cpcLocalCaps.bitmaps.sender.capsSmallCacheCellSize = MP_CACHE_CELLSIZE(MP_SMALL_TILE_WIDTH, MP_SMALL_TILE_WIDTH, maxSendBPP); g_cpcLocalCaps.bitmaps.sender.capsMediumCacheCellSize = MP_CACHE_CELLSIZE(MP_MEDIUM_TILE_WIDTH, MP_MEDIUM_TILE_HEIGHT, maxSendBPP); g_cpcLocalCaps.bitmaps.sender.capsLargeCacheCellSize = MP_CACHE_CELLSIZE(MP_LARGE_TILE_WIDTH, MP_LARGE_TILE_HEIGHT, maxSendBPP); } else { // // We can't use sizes of zero, 2.x nodes will fail if we do. But // we can use a tiny number so they don't allocate huge hunks of // memory for no reason. And 3.0 will treat '1' like '0'. // g_cpcLocalCaps.bitmaps.sender.capsSmallCacheNumEntries = 1; g_cpcLocalCaps.bitmaps.sender.capsSmallCacheCellSize = 1; g_cpcLocalCaps.bitmaps.sender.capsMediumCacheNumEntries = 1; g_cpcLocalCaps.bitmaps.sender.capsMediumCacheCellSize = 1; g_cpcLocalCaps.bitmaps.sender.capsLargeCacheNumEntries = 1; g_cpcLocalCaps.bitmaps.sender.capsLargeCacheCellSize = 1; } TRACE_OUT(("SBC small cache: %d entries, size %d", g_cpcLocalCaps.bitmaps.sender.capsSmallCacheNumEntries, g_cpcLocalCaps.bitmaps.sender.capsSmallCacheCellSize)); TRACE_OUT(("SBC medium cache: %d entries, size %d", g_cpcLocalCaps.bitmaps.sender.capsMediumCacheNumEntries, g_cpcLocalCaps.bitmaps.sender.capsMediumCacheCellSize)); TRACE_OUT(("SBC large cache: %d entries, size %d", g_cpcLocalCaps.bitmaps.sender.capsLargeCacheNumEntries, g_cpcLocalCaps.bitmaps.sender.capsLargeCacheCellSize)); // // PROTCAPS_ORDERS // g_cpcLocalCaps.orders.header.capID = CAPS_ID_ORDERS; g_cpcLocalCaps.orders.header.capSize = sizeof(g_cpcLocalCaps.orders); // // Fill in the SaveBitmap capabilities. // g_cpcLocalCaps.orders.capsSaveBitmapSize = TSHR_SSI_BITMAP_SIZE; g_cpcLocalCaps.orders.capsSaveBitmapXGranularity = TSHR_SSI_BITMAP_X_GRANULARITY; g_cpcLocalCaps.orders.capsSaveBitmapYGranularity = TSHR_SSI_BITMAP_Y_GRANULARITY; // // We support // * R20 Signatures (cell heights, better matching) // * Aspect matching // * Charset/code page matching // * Baseline text orders // * Em Heights // * DeltaX arrays for simulation if font not on remote // // // BOGUS LAURABU BUGBUG // // Baseline text orders not yet supported in Win95. But that's OK, // we don't mark any orders we generate on that platform with // NF_BASELINE, so they aren't treated as such. // g_cpcLocalCaps.orders.capsfFonts = CAPS_FONT_R20_SIGNATURE | CAPS_FONT_ASPECT | CAPS_FONT_CODEPAGE | CAPS_FONT_ALLOW_BASELINE | CAPS_FONT_EM_HEIGHT | CAPS_FONT_OLD_NEED_X | CAPS_FONT_NEED_X_SOMETIMES; // // Fill in which orders we support. // for (i = 0; i < ORD_NUM_LEVEL_1_ORDERS; i++) { // // Order indices for desktop-scrolling and memblt variants are not // to be negotiated by this mechanism... these currently consume // 3 order indices which must be excluded from this negotiation. // if ( (i == ORD_RESERVED_INDEX ) || (i == ORD_MEMBLT_R2_INDEX ) || (i == ORD_UNUSED_INDEX ) || (i == ORD_MEM3BLT_R2_INDEX) ) { continue; } g_cpcLocalCaps.orders.capsOrders[i] = ORD_LEVEL_1_ORDERS; } g_cpcLocalCaps.orders.capsMaxOrderlevel = ORD_LEVEL_1_ORDERS; // // Fill in encoding capabilities // // // Keep the "encoding disabled" option, it's handy for using our // protocol analyzer // COM_ReadProfInt(DBG_INI_SECTION_NAME, OE2_INI_2NDORDERENCODING, CAPS_ENCODING_DEFAULT, &property); g_cpcLocalCaps.orders.capsEncodingLevel = (TSHR_UINT16)property; // // Get the app and desktop icons, big and small // g_hetASIcon = LoadIcon(g_asInstance, MAKEINTRESOURCE(IDI_SHAREICON)); if (!g_hetASIcon) { ERROR_OUT(("HET_Init: Failed to load app icon")); DC_QUIT; } g_hetDeskIcon = LoadIcon(g_asInstance, MAKEINTRESOURCE(IDI_DESKTOPICON)); if (!g_hetDeskIcon) { ERROR_OUT(("HET_Init: failed to load desktop icon")); DC_QUIT; } // Get the small icon, created, that we paint on the window bar items g_hetASIconSmall = (HICON)LoadImage(g_asInstance, MAKEINTRESOURCE(IDI_SHAREICON), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR); if (!g_hetASIconSmall) { ERROR_OUT(("HET_Init: Failed to load app small icon")); DC_QUIT; } g_hetDeskIconSmall = (HICON)LoadImage(g_asInstance, MAKEINTRESOURCE(IDI_DESKTOPICON), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR); if (!g_hetDeskIconSmall) { ERROR_OUT(("HET_Init: Failed to load desktop small icon")); DC_QUIT; } // // Get the checkmark image // g_hetCheckBitmap = LoadBitmap(NULL, MAKEINTRESOURCE(OBM_CHECK)); if (!g_hetCheckBitmap) { ERROR_OUT(("HET_Init: Failed to load checkmark bitmap")); DC_QUIT; } // // Create a bolded font for shared items in the host list // GetObject(GetStockObject(DEFAULT_GUI_FONT), sizeof(lf), &lf); lf.lfWeight += FW_LIGHT; g_hetSharedFont = CreateFontIndirect(&lf); if (!g_hetSharedFont) { ERROR_OUT(("HET_Init: Failed to create shared item font")); DC_QUIT; } rc = TRUE; DC_EXIT_POINT: DebugExitBOOL(HET_Init, rc); return(rc); } // // HET_Term() // // Cleanup hosting objects // void HET_Term(void) { DebugEntry(HET_Term); if (g_hetSharedFont != NULL) { DeleteFont(g_hetSharedFont); g_hetSharedFont = NULL; } if (g_hetCheckBitmap != NULL) { DeleteBitmap(g_hetCheckBitmap); g_hetCheckBitmap = NULL; } if (g_hetDeskIconSmall != NULL) { DestroyIcon(g_hetDeskIconSmall); g_hetDeskIconSmall = NULL; } if (g_hetDeskIcon != NULL) { DestroyIcon(g_hetDeskIcon); g_hetDeskIcon = NULL; } if (g_hetASIconSmall != NULL) { DestroyIcon(g_hetASIconSmall); g_hetASIconSmall = NULL; } if (g_hetASIcon != NULL) { DestroyIcon(g_hetASIcon); g_hetASIcon = NULL; } DebugExitVOID(HET_Term); } // // HET_ShareDesktop() // void ASShare::HET_ShareDesktop(void) { ASPerson * pasT; DebugEntry(ASShare:HET_ShareDesktop); // // If we're sharing apps, ignore this. // if (m_pasLocal->hetCount != 0) { WARNING_OUT(("Ignoring share desktop request, sharing apps")); DC_QUIT; } TRACE_OUT(("HET_ShareDesktop: starting share")); if (!HETStartHosting(TRUE)) { ERROR_OUT(("HET_ShareDesktop cannot start sharing desktop")); DC_QUIT; } // // Update the count of hosted entities (ie user-hosted windows) // HETUpdateLocalCount(HET_DESKTOPSHARED); // // Get the desktop(s) repainted if anybody's viewing it. // ASSERT(m_pHost); m_pHost->HET_RepaintAll(); DC_EXIT_POINT: DebugExitVOID(ASShare::HET_ShareDesktop); } // // HET_UnshareAll() // Unshares everything including the desktop. If we had been sharing // apps before, we will unshare them all. // void ASShare::HET_UnshareAll(void) { DebugEntry(ASShare::HET_UnshareAll); if (m_pasLocal->hetCount != 0) { HETUpdateLocalCount(0); } DebugExitVOID(ASShare::HET_UnshareAll); } // // HET_PartyJoiningShare() // BOOL ASShare::HET_PartyJoiningShare(ASPerson * pasPerson) { BOOL rc = TRUE; DebugEntry(ASShare::HET_PartyJoiningShare); HET_CalcViewers(NULL); DebugExitBOOL(ASShare::HET_PartyJoiningShare, rc); return(rc); } // // HET_PartyLeftShare() // void ASShare::HET_PartyLeftShare(ASPerson * pasPerson) { DebugEntry(ASShare::HET_PartyLeftShare); // This guy is leaving the share, cleanup if he was sharing. ValidatePerson(pasPerson); if (pasPerson->hetCount != 0) { // This person is hosting if (pasPerson == m_pasLocal) { HETUpdateLocalCount(0); } else { HETUpdateRemoteCount(pasPerson, 0); } } // // If we're hosting, stop viewing if this is the last person in the share. // HET_CalcViewers(pasPerson); DebugExitVOID(ASShare::HET_PartyLeftShare); } // // HET_CalcViewers() // // If we or a remote is viewing our shared stuff, then we must accumulate // graphic output. If not, don't other, but keep the app tracked as necessary. // // This is called when we start to host, when somebody joins, or somebody // leaves the conference. // void ASShare::HET_CalcViewers(ASPerson * pasLeaving) { BOOL fViewers; DebugEntry(ASShare::HET_CalcViewers); fViewers = FALSE; if (m_pHost) { if (m_scfViewSelf) { fViewers = TRUE; } else if (!pasLeaving) { // // Nobody is leaving, so just check if anybody else is in the // share. // if (m_pasLocal->pasNext) { fViewers = TRUE; } } else if (pasLeaving->pasNext || (m_pasLocal->pasNext != pasLeaving)) { // // Sombody is leaving. // The person leaving isn't the only other one besides us in the // share, since there are others after it or before it in the // members linked list. // fViewers = TRUE; } } if (fViewers != m_hetViewers) { HET_VIEWER viewer; m_hetViewers = fViewers; viewer.viewersPresent = fViewers; OSI_FunctionRequest(HET_ESC_VIEWER, (LPOSI_ESCAPE_HEADER)&viewer, sizeof(viewer)); } DebugExitVOID(ASShare::HET_CalcViewers); } // // HET_ReceivedPacket() // void ASShare::HET_ReceivedPacket ( ASPerson * pasPerson, PS20DATAPACKET pPacket ) { PHETPACKET pHETPacket; DebugEntry(ASShare:;HET_ReceivedPacket); ValidatePerson(pasPerson); pHETPacket = (PHETPACKET)pPacket; switch (pHETPacket->msg) { case HET_MSG_NUMHOSTED: HETUpdateRemoteCount(pasPerson, pHETPacket->hostState); break; default: ERROR_OUT(("Unknown HET packet type %u from [%d]", pHETPacket->msg, pasPerson->mcsID)); break; } DebugExitVOID(ASShare::HET_ReceivedPacket); } // // HET_SyncCommon() // // Called when somebody joins a share, after it is fully joined. We repaint // all shared windows and send the current hosted top-level count. // // Also called when sharing, and somebody joins later. // // NOTE that some of the resets don't do anything when are just starting to // share. But all are quick and benign. // void ASHost::HET_SyncCommon(void) { OSI_ESCAPE_HEADER osi; DebugEntry(ASHost::HET_SyncCommon); m_upfSyncTokenRequired = TRUE; BA_SyncOutgoing(); OE2_SyncOutgoing(); // To reset order encoding OA_SyncOutgoing(); // To clear pending orders SBC_SyncOutgoing(); // To clear bitmap cache PM_SyncOutgoing(); // To clear palette cache SSI_SyncOutgoing(); // To reset savebits orders CM_SyncOutgoing(); // To send cursor shape/pos // // Tell the driver we are syncing // OSI_FunctionRequest(OSI_ESC_SYNC_NOW, &osi, sizeof(osi)); DebugExitVOID(ASHost::HET_SyncCommon); } // // HET_SyncAlreadyHosting() // Called in a sync when we are already hosting and somebody joins call // void ASHost::HET_SyncAlreadyHosting(void) { DebugEntry(ASHost::HET_SyncAlreadyHosting); HET_RepaintAll(); // Send out the current hosted count m_pShare->m_hetRetrySendState = TRUE; DebugExitVOID(ASHost::HET_SyncAlreadyHosting); } // // HET_RepaintAll() // // Repaints all shared stuff if there's at least two people in the share... // void ASHost::HET_RepaintAll(void) { DebugEntry(ASHost::HET_RepaintAll); ASSERT(m_pShare); ASSERT(m_pShare->m_pasLocal); if (m_pShare->m_hetViewers) { // // Only repaint if somebody's viewing // if (m_pShare->m_pasLocal->hetCount == HET_DESKTOPSHARED) { // Desktop sharing, so repaint desktop(s) USR_RepaintWindow(NULL); OSI_RepaintDesktop(); //special repaint for winlogon desktop } else { ERROR_OUT(("HET_RepaintAll - not sharing dekstop!")); } } DebugExitVOID(ASHost::HET_RepaintAll); } // // HET_Periodic() // void ASShare::HET_Periodic(void) { DebugEntry(ASShare::HET_Periodic); if (m_hetRetrySendState) { TRACE_OUT(( "Retry sending hosted count")); HETSendLocalCount(); } DebugExitVOID(ASShare::HET_Periodic); } // // HET_WindowIsHosted - see het.h // BOOL ASShare::HET_WindowIsHosted(HWND hwnd) { BOOL rc = FALSE; DebugEntry(ASShare::HET_WindowIsHosted); // // Desktop sharing: everything is shared // if (m_pasLocal->hetCount == HET_DESKTOPSHARED) { rc = TRUE; } DebugExitBOOL(ASShare::HET_WindowIsHosted, rc); return(rc); } // // HETStartHosting() // // Called when we are about to begin sharing windows. fDesktop is TRUE if // we are sharing the entire desktop, FALSE if just individual windows. // BOOL ASShare::HETStartHosting(BOOL fDesktop) { BOOL rc = FALSE; DebugEntry(ASShare::HETStartHosting); // // Create the hosting object // ASSERT(!m_pHost); m_pHost = new ASHost; if (!m_pHost) { ERROR_OUT(("HETStartHosting: couldn't create m_pHost")); DC_QUIT; } ZeroMemory(m_pHost, sizeof(*(m_pHost))); SET_STAMP(m_pHost, HOST); // // Init hosting // if (!m_pHost->HET_HostStarting(this)) { ERROR_OUT(("Failed to init hosting for local person")); DC_QUIT; } // // Start tracking graphics/windows // ASSERT(fDesktop); { HET_SHARE_DESKTOP hdr; // // Shortcut directly to display driver. No need to track windows // since everything will be shared. // if (!OSI_FunctionRequest(HET_ESC_SHARE_DESKTOP, (LPOSI_ESCAPE_HEADER)&hdr, sizeof(hdr))) { ERROR_OUT(("HET_ESC_SHARE_DESKTOP failed")); DC_QUIT; } } if (m_scfViewSelf && !HET_ViewStarting(m_pasLocal)) { ERROR_OUT(("ViewSelf option is on, but can't create ASView data")); DC_QUIT; } HET_CalcViewers(NULL); rc = TRUE; DC_EXIT_POINT: // // Return to caller // DebugExitBOOL(ASShare::HETStartHosting, rc); return(rc); } // // // Name: HETStopHosting // // Description: Called when the last hosted window is unshared // ALWAYS CALL THIS AFTER the "hethostedTopLevel" count is 0. // // Params: none // // void ASShare::HETStopHosting(BOOL fDesktop) { DebugEntry(ASShare::HETStopHosting); m_hetViewers = FALSE; // // Stop tracking graphics/windows. This will stop viewing, then uninstall // hooks. // ASSERT(fDesktop); { HET_UNSHARE_DESKTOP hdr; // // There is no window tracking, just shortcut directly to the // display driver. // OSI_FunctionRequest(HET_ESC_UNSHARE_DESKTOP, (LPOSI_ESCAPE_HEADER)&hdr, sizeof(hdr)); } // // Tell areas we are finished hosting // if (m_pHost) { // // If we're viewing ourself, kill the view first // if (m_scfViewSelf) { HET_ViewEnded(m_pasLocal); } m_pHost->HET_HostEnded(); // // Delete host object // delete m_pHost; m_pHost = NULL; } // // Return to caller // DebugExitVOID(ASShare::HETStopHosting); } // // HETSendLocalCount() // This sends the hosting count to remotes. // * If zero, we are not sharing // * If one, we are sharing apps // * If 0xFFFF, we are sharing desktop // // Note that we used to send the real count of top level windows, so every // time a new window came or went, we would broadcast a packet. But // remotes only care when the value goes from zero to non-zero or back, // and when non-zero if it's the special desktop value or not. So don't // repeatedly broadcast values remotes don't care about! // void ASShare::HETSendLocalCount(void) { PHETPACKET pHETPacket; #ifdef _DEBUG UINT sentSize; #endif // _DEBUG DebugEntry(ASShare::HETSendLocalCount); // // Allocate a packet for the HET data. // pHETPacket = (PHETPACKET)SC_AllocPkt(PROT_STR_MISC, g_s20BroadcastID, sizeof(HETPACKET)); if (!pHETPacket) { WARNING_OUT(("Failed to alloc HET host packet")); m_hetRetrySendState = TRUE; DC_QUIT; } // // Packet successfully allocated. Fill in the data and send it. // pHETPacket->header.data.dataType = DT_HET; pHETPacket->msg = HET_MSG_NUMHOSTED; switch (m_pasLocal->hetCount) { case 0: // Not hosting pHETPacket->hostState = HET_NOTHOSTING; break; case HET_DESKTOPSHARED: // Sharing desktop - 3.0 only pHETPacket->header.data.dataType = DT_HET30; pHETPacket->hostState = HET_DESKTOPSHARED; break; default: // Sharing apps pHETPacket->hostState = HET_APPSSHARED; break; } // // Compress and send the packet. // #ifdef _DEBUG sentSize = #endif // _DEBUG DCS_CompressAndSendPacket(PROT_STR_MISC, g_s20BroadcastID, &(pHETPacket->header), sizeof(*pHETPacket)); TRACE_OUT(("HET packet size: %08d, sent %08d", sizeof(*pHETPacket), sentSize)); TRACE_OUT(("Sent new HET packet (%d)", m_pasLocal->hetCount)); m_hetRetrySendState = FALSE; // // Return to caller // DC_EXIT_POINT: DebugExitVOID(ASShare::HETSendLocalCount); } // // HETUpdateLocalCount() // void ASShare::HETUpdateLocalCount(UINT newCount) { UINT oldCount; DebugEntry(ASShare::HETUpdateLocalCount); oldCount = m_pasLocal->hetCount; m_pasLocal->hetCount = newCount; if ((oldCount == 0) && (newCount != 0)) { // // Don't bother sending net packets if nobody is viewing // if (m_hetViewers) { HETSendLocalCount(); } HETCheckSharing(TRUE); } else if ((oldCount != 0) && (newCount == 0)) { if (m_hetViewers) { // // Ending host, desktop or apps // HETSendLocalCount(); } // // The local guy is stopping sharing. // HETStopHosting(oldCount == HET_DESKTOPSHARED); HETCheckSharing(FALSE); } DebugExitVOID(ASShare::HETUpdateLocalCount); } // // HETUpdateRemoteCount() // // Updates the count of shared top level windows from a remote, and notifies // the UI on transition from/to zero if a remote. If local, kills the share. // void ASShare::HETUpdateRemoteCount ( ASPerson * pasPerson, UINT newCount ) { UINT oldCount; DebugEntry(ASShare::HETUpdateRemoteCount); ValidatePerson(pasPerson); ASSERT(pasPerson != m_pasLocal); oldCount = pasPerson->hetCount; pasPerson->hetCount = newCount; TRACE_OUT(("HETUpdateRemoteCount: Person [%d] old %d, new %d", pasPerson->mcsID, oldCount, newCount)); // // We generate events for remote people if // * They were sharing but now they aren't // * There weren't sharing but now they are // if ((oldCount == 0) && (newCount != 0)) { // // The remote dude started to share // if (!HET_ViewStarting(pasPerson)) { ERROR_OUT(("HET_ViewStarting failed; pretending remote not sharing")); pasPerson->hetCount = 0; HET_ViewEnded(pasPerson); } else { HETCheckSharing(TRUE); } } else if ((oldCount != 0) && (newCount == 0)) { // // The remote dude stopped sharing. Notify the UI also. // HET_ViewEnded(pasPerson); HETCheckSharing(FALSE); } DebugExitVOID(ASShare::HETUpdateRemoteCount); } // // HETCheckSharing() // Called when any member of the conference (local or remote) transitions // to/from sharing. When the first person has shared something, we notify // the UI. When the last person has stopped sharing, we kill the share which // will notify the UI. // void ASShare::HETCheckSharing(BOOL fStarting) { DebugEntry(ASShare::HETCheckSharing); if (fStarting) { ++m_hetHostCount; if (m_hetHostCount == 1) { // First host started TRACE_OUT(("First person started hosting")); DCS_NotifyUI(SH_EVT_SHARING_STARTED, 0, 0); } } else { ASSERT(m_hetHostCount > 0); --m_hetHostCount; if (m_hetHostCount == 0) { // // Last host stopped sharing -- end share if we're not cleaning // up after the fact. But don't do it NOW, post a message. // We may have come in here because the share is ending already. // PostMessage(g_asMainWindow, DCS_KILLSHARE_MSG, 0, 0); } } DebugExitVOID(ASShare::HETCheckSharing); } // // HET_HostStarting() // // Called when we start to host applications. This creates our host data // then calls the component HostStarting() routines // BOOL ASHost::HET_HostStarting(ASShare * pShare) { BOOL rc = FALSE; DebugEntry(ASHost::HET_HostStarting); // Set back pointer to share m_pShare = pShare; // // Turn effects off // HET_SetGUIEffects(FALSE, &m_hetEffects); OSI_SetGUIEffects(FALSE); // // Now call HostStarting() routines // if (!USR_HostStarting()) { ERROR_OUT(("USR_HostStarting failed")); DC_QUIT; } if (!OE2_HostStarting()) { ERROR_OUT(("OE2_HostStarting failed")); DC_QUIT; } if (!SBC_HostStarting()) { ERROR_OUT(("SBC_HostStarting failed")); DC_QUIT; } if (!CM_HostStarting()) { ERROR_OUT(("CM_HostStarting failed")); DC_QUIT; } if (!SSI_HostStarting()) { ERROR_OUT(("SSI_HostStarting failed")); DC_QUIT; } if (!PM_HostStarting()) { ERROR_OUT(("PM_HostStarting failed")); DC_QUIT; } if (!SWL_HostStarting()) { ERROR_OUT(("SWL_HostStarting failed")); DC_QUIT; } if (!VIEW_HostStarting()) { ERROR_OUT(("VIEW_HostStarting failed")); DC_QUIT; } // // Now reset OUTGOING info. 2.x nodes do not; that's why we have to // hang on to RBC, OD2, CM, PM data for them. When 2.x compat is gone, // we can move ASPerson data in to ASView, which is only around while // the person is in fact hosting. // OA_LocalHostReset(); // // Reset OUTGOING data. // Note corresponding cleanup for 3.0 nodes // in CM, OD2, RBC, and PM. // Note that we don't need to reset SSI incoming goop, since we will // clear all pending orders and are invalidating everything shared // from scratch. There will be no reference to a previous savebits. // HET_SyncCommon(); rc = TRUE; DC_EXIT_POINT: DebugExitBOOL(ASHost::HET_HostStarting, rc); return(rc); } // // HET_HostEnded() // // Called when we stop hosting applications. // void ASHost::HET_HostEnded(void) { DebugEntry(ASHost::HET_HostEnded); // // Call HostEnded() routines // CA_HostEnded(); PM_HostEnded(); CM_HostEnded(); SBC_HostEnded(); OE2_HostEnded(); USR_HostEnded(); // // Restore windows animation. // HET_SetGUIEffects(TRUE, &m_hetEffects); OSI_SetGUIEffects(TRUE); DebugExitVOID(ASHost::HET_HostEnded); } // // HET_ViewStarting() // // Called to create the data needed to view somebody who is hosting. // BOOL ASShare::HET_ViewStarting(ASPerson * pasPerson) { BOOL rc = FALSE; DebugEntry(ASShare::HET_ViewStarting); ValidatePerson(pasPerson); // // Create ASView object // ASSERT(!pasPerson->m_pView); // Allocate VIEW structure pasPerson->m_pView = new ASView; if (!pasPerson->m_pView) { // Abject, total, failure. ERROR_OUT(("HET_ViewStarting: Couldn't allocate ASView for [%d]", pasPerson->mcsID)); DC_QUIT; } ZeroMemory(pasPerson->m_pView, sizeof(*(pasPerson->m_pView))); SET_STAMP(pasPerson->m_pView, VIEW); // // Now call ViewStarting routines // if (!USR_ViewStarting(pasPerson)) { ERROR_OUT(("USR_ViewStarting failed")); DC_QUIT; } if (!OD2_ViewStarting(pasPerson)) { ERROR_OUT(("OD2_ViewStarting failed")); DC_QUIT; } if (!OD_ViewStarting(pasPerson)) { ERROR_OUT(("OD_ViewStarting failed")); DC_QUIT; } if (!RBC_ViewStarting(pasPerson)) { ERROR_OUT(("RBC_ViewStarting failed")); DC_QUIT; } if (!CM_ViewStarting(pasPerson)) { ERROR_OUT(("CM_ViewStarting failed")); DC_QUIT; } if (!SSI_ViewStarting(pasPerson)) { ERROR_OUT(("SSI_ViewStarting failed")); DC_QUIT; } if (!PM_ViewStarting(pasPerson)) { ERROR_OUT(("PM_ViewStarting failed")); DC_QUIT; } if (!VIEW_ViewStarting(pasPerson)) { ERROR_OUT(("VIEW_ViewStarting failed")); DC_QUIT; } if (!CA_ViewStarting(pasPerson)) { ERROR_OUT(("CA_ViewStarting failed")); DC_QUIT; } rc = TRUE; DC_EXIT_POINT: DebugExitBOOL(ASShare::HET_ViewStarting, rc); return(rc); } // // HET_ViewEnded() // // Called when we stop viewing a host // void ASShare::HET_ViewEnded(ASPerson * pasPerson) { DebugEntry(ASShare::HET_ViewEnded); ValidatePerson(pasPerson); if (pasPerson->m_pView) { // // Call the component ViewEnded routines // CA_ViewEnded(pasPerson); VIEW_ViewEnded(pasPerson); PM_ViewEnded(pasPerson); SSI_ViewEnded(pasPerson); CM_ViewEnded(pasPerson); RBC_ViewEnded(pasPerson); OD_ViewEnded(pasPerson); OD2_ViewEnded(pasPerson); USR_ViewEnded(pasPerson); delete pasPerson->m_pView; pasPerson->m_pView = NULL; } DebugExitVOID(ASShare::HET_ViewEnded); } // // HET_SetGUIEffects // // Turns various animations off/on when we start/stop hosting, to improve // performance. Currently, we mess with // * min animation // * all of the effects in SPI_SETUIEFFECTS (tooltip fade, menu animation, // etc.) // * cursor shadows // // We don't turn off smooth scroll or full drag. // void HET_SetGUIEffects ( BOOL fOn, GUIEFFECTS * pEffects ) { DebugEntry(HET_SetGUIEffects); ASSERT(!IsBadWritePtr(pEffects, sizeof(*pEffects))); // // NB. We deliberately do not track the state of animation whilst we // are sharing. A determined user could, using some other app (such as // the TweakUI control panel applet) reenable animation whilst in a // share. We will respect this. // // We only affect the current 'in memory' setting - we do not write our // temporary change to file. // if (fOn) { // // If it was on before, restore it. // if (pEffects->hetAnimation.iMinAnimate) { pEffects->hetAnimation.cbSize = sizeof(pEffects->hetAnimation); SystemParametersInfo(SPI_SETANIMATION, sizeof(pEffects->hetAnimation), &pEffects->hetAnimation, 0); } if (pEffects->hetAdvanced) { SystemParametersInfo(SPI_SETUIEFFECTS, 0, (LPVOID)pEffects->hetAdvanced, 0); } if (pEffects->hetCursorShadow) { SystemParametersInfo(SPI_SETCURSORSHADOW, 0, (LPVOID)pEffects->hetCursorShadow, 0); } } else { // // Find out what animations are on. // ZeroMemory(&pEffects->hetAnimation, sizeof(pEffects->hetAnimation)); pEffects->hetAnimation.cbSize = sizeof(pEffects->hetAnimation); SystemParametersInfo(SPI_GETANIMATION, sizeof(pEffects->hetAnimation), &pEffects->hetAnimation, 0); pEffects->hetAdvanced = FALSE; SystemParametersInfo(SPI_GETUIEFFECTS, 0, &pEffects->hetAdvanced, 0); pEffects->hetCursorShadow = FALSE; SystemParametersInfo(SPI_GETCURSORSHADOW, 0, &pEffects->hetCursorShadow, 0); // // Turn off the animations which are on. // if (pEffects->hetAnimation.iMinAnimate) { // // It's currently enabled, suppress it. // pEffects->hetAnimation.cbSize = sizeof(pEffects->hetAnimation); pEffects->hetAnimation.iMinAnimate = FALSE; SystemParametersInfo(SPI_SETANIMATION, sizeof(pEffects->hetAnimation), &pEffects->hetAnimation, 0); // SPI will wipe this out. Keep it set so we know to restore it. pEffects->hetAnimation.iMinAnimate = TRUE; } if (pEffects->hetAdvanced) { SystemParametersInfo(SPI_SETUIEFFECTS, 0, FALSE, 0); } if (pEffects->hetCursorShadow) { SystemParametersInfo(SPI_SETCURSORSHADOW, 0, FALSE, 0); } } DebugExitVOID(ASHost::HET_SetGUIEffects); }