Page MenuHomePhabricator
Differential D3499

[web] [feat] add mark as unread styles for selected and hovered states
ClosedPublic
Actions

Authored by • benschac on Mar 23 2022, 8:13 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 10, 2:21 AM
Unknown Object (File)
Mon, Mar 10, 2:21 AM
Unknown Object (File)
Mon, Mar 10, 2:21 AM
Unknown Object (File)
Mon, Mar 10, 2:17 AM
Unknown Object (File)
Mon, Mar 10, 2:15 AM
Unknown Object (File)
Jan 31 2025, 6:09 AM
Unknown Object (File)
Jan 26 2025, 7:39 AM
Unknown Object (File)
Jan 15 2025, 4:51 PM
View All Files
Subscribers
• adrian
ashoat
• karol
tomek

Details

Reviewers
atul
tomek
• jacek
ashoat
Commits
rCOMMc2358a3f9af8: [web] [feat] add mark as unread styles for selected and hovered states
Summary

per conversation in D3422 updating active and hovered styles for mark as unread (this is option 1)

Image 2022-03-22 at 9.35.04 AM.jpg (910×893 px, 218 KB)

https://linear.app/comm/issue/ENG-733/mark-as-read-button-has-white-text-on-light-background-when-thread-is

Screen Recording 2022-03-23 at 11.17.50 AM.gif (501×1 px, 4 MB)

Test Plan

hover and select chat thread list items, click mark as unread menu button. Make sure they match.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

• benschac created this revision.Mar 23 2022, 8:13 AM
Herald added subscribers: • karol, • adrian, tomek, ashoat. · View Herald TranscriptMar 23 2022, 8:13 AM
• benschac added reviewers: tomek, • jacek.Mar 23 2022, 8:14 AM
• benschac added a parent revision: D3493: [web] [refactor] move props to single destructure in top of chat thread list item menu component.
Harbormaster completed remote builds in B7540: Diff 10609.Mar 23 2022, 8:18 AM
• benschac requested review of this revision.Mar 23 2022, 8:18 AM
• benschac edited the summary of this revision. (Show Details)Mar 23 2022, 8:18 AM
• benschac edited the summary of this revision. (Show Details)
• benschac updated this revision to Diff 10612.Mar 23 2022, 8:19 AM

add space

• benschac edited the summary of this revision. (Show Details)Mar 23 2022, 8:23 AM
• benschac edited the summary of this revision. (Show Details)
• benschac added a reviewer: ashoat.
• benschac added a comment.Mar 23 2022, 8:25 AM

adding ashoat as a reviewer since we ah-hoc designed mark as unread and want this to be in your queue. Feel free to remove yourself if it's not relevant.

Harbormaster completed remote builds in B7543: Diff 10612.Mar 23 2022, 8:29 AM
• benschac added a child revision: D3500: [web] [refactor] css color should be white.Mar 23 2022, 10:22 AM
ashoat accepted this revision.Mar 23 2022, 8:34 PM

It's kind of hard for me to tell what's going on between D3422 and this diff. I'm not sure what the visual repercussions are here, and why there need to be two diffs (what does the second diff do). But I guess it looks good?

It seems like the easiest way for me to review this is just to get it landed and see what it looks like on prod. Another reason to prioritize ENG-889.

This revision is now accepted and ready to land.Mar 23 2022, 8:34 PM
Closed by commit rCOMMc2358a3f9af8: [web] [feat] add mark as unread styles for selected and hovered states (authored by • benschac). · Explain WhyMar 24 2022, 12:30 PM
This revision was automatically updated to reflect the committed changes.
• benschac added a commit: rCOMMc2358a3f9af8: [web] [feat] add mark as unread styles for selected and hovered states.

Revision Contents
Changeset List

Diff 10671

View Options

web/chat/chat-thread-list-item-menu.css

  • This file was copied to services/backup/src/Reactors/client/blob/BlobPutClientReactor.cpp.
#pragma once #pragma once
#include "ClientBidiReactorBase.h"
#include "Constants.h" #include "Constants.h"
#include "../_generated/blob.grpc.pb.h" #include "../_generated/blob.grpc.pb.h"
#include "../_generated/blob.pb.h" #include "../_generated/blob.pb.h"
#include "ClientBidiReactorBase.h"
#include <folly/MPMCQueue.h> #include <folly/MPMCQueue.h>
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <condition_variable> #include <condition_variable>
#include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class BlobPutClientReactor class BlobPutClientReactor
Show All 22 Linespublic:
void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk); void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk);
std::unique_ptr<grpc::Status> prepareRequest( std::unique_ptr<grpc::Status> prepareRequest(
blob::PutRequest &request, blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) override; std::shared_ptr<blob::PutResponse> previousResponse) override;
void doneCallback() override; void doneCallback() override;
grpc::Status getStatus() const; grpc::Status getStatus() const;
}; };
BlobPutClientReactor::BlobPutClientReactor(
const std::string &holder,
const std::string &hash,
std::condition_variable *terminationNotifier)
: holder(holder),
hash(hash),
dataChunks(folly::MPMCQueue<std::string>(100)),
terminationNotifier(terminationNotifier) {
}
void BlobPutClientReactor::scheduleSendingDataChunk(
std::unique_ptr<std::string> dataChunk) {
if (!this->dataChunks.write(std::move(*dataChunk))) {
throw std::runtime_error(
"Error scheduling sending a data chunk to send to the blob service");
}
}
std::unique_ptr<grpc::Status> BlobPutClientReactor::prepareRequest(
blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) {
if (this->state == State::SEND_HOLDER) {
this->request.set_holder(this->holder);
this->state = State::SEND_HASH;
return nullptr;
}
if (this->state == State::SEND_HASH) {
request.set_blobhash(this->hash);
this->state = State::SEND_CHUNKS;
return nullptr;
}
if (previousResponse->dataexists()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
std::string dataChunk;
this->dataChunks.blockingRead(dataChunk);
if (dataChunk.empty()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
request.set_datachunk(dataChunk);
return nullptr;
}
void BlobPutClientReactor::doneCallback() {
this->terminationNotifier->notify_one();
}
grpc::Status BlobPutClientReactor::getStatus() const {
return this->status;
}
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

web/chat/chat-thread-list-item-menu.react.js

  • This file was copied to services/backup/src/Reactors/client/blob/BlobPutClientReactor.cpp.
#pragma once #pragma once
#include "ClientBidiReactorBase.h"
#include "Constants.h" #include "Constants.h"
#include "../_generated/blob.grpc.pb.h" #include "../_generated/blob.grpc.pb.h"
#include "../_generated/blob.pb.h" #include "../_generated/blob.pb.h"
#include "ClientBidiReactorBase.h"
#include <folly/MPMCQueue.h> #include <folly/MPMCQueue.h>
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <condition_variable> #include <condition_variable>
#include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class BlobPutClientReactor class BlobPutClientReactor
Show All 22 Linespublic:
void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk); void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk);
std::unique_ptr<grpc::Status> prepareRequest( std::unique_ptr<grpc::Status> prepareRequest(
blob::PutRequest &request, blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) override; std::shared_ptr<blob::PutResponse> previousResponse) override;
void doneCallback() override; void doneCallback() override;
grpc::Status getStatus() const; grpc::Status getStatus() const;
}; };
BlobPutClientReactor::BlobPutClientReactor(
const std::string &holder,
const std::string &hash,
std::condition_variable *terminationNotifier)
: holder(holder),
hash(hash),
dataChunks(folly::MPMCQueue<std::string>(100)),
terminationNotifier(terminationNotifier) {
}
void BlobPutClientReactor::scheduleSendingDataChunk(
std::unique_ptr<std::string> dataChunk) {
if (!this->dataChunks.write(std::move(*dataChunk))) {
throw std::runtime_error(
"Error scheduling sending a data chunk to send to the blob service");
}
}
std::unique_ptr<grpc::Status> BlobPutClientReactor::prepareRequest(
blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) {
if (this->state == State::SEND_HOLDER) {
this->request.set_holder(this->holder);
this->state = State::SEND_HASH;
return nullptr;
}
if (this->state == State::SEND_HASH) {
request.set_blobhash(this->hash);
this->state = State::SEND_CHUNKS;
return nullptr;
}
if (previousResponse->dataexists()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
std::string dataChunk;
this->dataChunks.blockingRead(dataChunk);
if (dataChunk.empty()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
request.set_datachunk(dataChunk);
return nullptr;
}
void BlobPutClientReactor::doneCallback() {
this->terminationNotifier->notify_one();
}
grpc::Status BlobPutClientReactor::getStatus() const {
return this->status;
}
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

web/chat/chat-thread-list.css

  • This file was copied to services/backup/src/Reactors/client/blob/BlobPutClientReactor.cpp.
#pragma once #pragma once
#include "ClientBidiReactorBase.h"
#include "Constants.h" #include "Constants.h"
#include "../_generated/blob.grpc.pb.h" #include "../_generated/blob.grpc.pb.h"
#include "../_generated/blob.pb.h" #include "../_generated/blob.pb.h"
#include "ClientBidiReactorBase.h"
#include <folly/MPMCQueue.h> #include <folly/MPMCQueue.h>
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <condition_variable> #include <condition_variable>
#include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class BlobPutClientReactor class BlobPutClientReactor
Show All 22 Linespublic:
void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk); void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk);
std::unique_ptr<grpc::Status> prepareRequest( std::unique_ptr<grpc::Status> prepareRequest(
blob::PutRequest &request, blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) override; std::shared_ptr<blob::PutResponse> previousResponse) override;
void doneCallback() override; void doneCallback() override;
grpc::Status getStatus() const; grpc::Status getStatus() const;
}; };
BlobPutClientReactor::BlobPutClientReactor(
const std::string &holder,
const std::string &hash,
std::condition_variable *terminationNotifier)
: holder(holder),
hash(hash),
dataChunks(folly::MPMCQueue<std::string>(100)),
terminationNotifier(terminationNotifier) {
}
void BlobPutClientReactor::scheduleSendingDataChunk(
std::unique_ptr<std::string> dataChunk) {
if (!this->dataChunks.write(std::move(*dataChunk))) {
throw std::runtime_error(
"Error scheduling sending a data chunk to send to the blob service");
}
}
std::unique_ptr<grpc::Status> BlobPutClientReactor::prepareRequest(
blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) {
if (this->state == State::SEND_HOLDER) {
this->request.set_holder(this->holder);
this->state = State::SEND_HASH;
return nullptr;
}
if (this->state == State::SEND_HASH) {
request.set_blobhash(this->hash);
this->state = State::SEND_CHUNKS;
return nullptr;
}
if (previousResponse->dataexists()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
std::string dataChunk;
this->dataChunks.blockingRead(dataChunk);
if (dataChunk.empty()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
request.set_datachunk(dataChunk);
return nullptr;
}
void BlobPutClientReactor::doneCallback() {
this->terminationNotifier->notify_one();
}
grpc::Status BlobPutClientReactor::getStatus() const {
return this->status;
}
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

web/theme.css

  • This file was copied to services/backup/src/Reactors/client/blob/BlobPutClientReactor.cpp.
#pragma once #pragma once
#include "ClientBidiReactorBase.h"
#include "Constants.h" #include "Constants.h"
#include "../_generated/blob.grpc.pb.h" #include "../_generated/blob.grpc.pb.h"
#include "../_generated/blob.pb.h" #include "../_generated/blob.pb.h"
#include "ClientBidiReactorBase.h"
#include <folly/MPMCQueue.h> #include <folly/MPMCQueue.h>
#include <grpcpp/grpcpp.h> #include <grpcpp/grpcpp.h>
#include <condition_variable> #include <condition_variable>
#include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class BlobPutClientReactor class BlobPutClientReactor
Show All 22 Linespublic:
void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk); void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk);
std::unique_ptr<grpc::Status> prepareRequest( std::unique_ptr<grpc::Status> prepareRequest(
blob::PutRequest &request, blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) override; std::shared_ptr<blob::PutResponse> previousResponse) override;
void doneCallback() override; void doneCallback() override;
grpc::Status getStatus() const; grpc::Status getStatus() const;
}; };
BlobPutClientReactor::BlobPutClientReactor(
const std::string &holder,
const std::string &hash,
std::condition_variable *terminationNotifier)
: holder(holder),
hash(hash),
dataChunks(folly::MPMCQueue<std::string>(100)),
terminationNotifier(terminationNotifier) {
}
void BlobPutClientReactor::scheduleSendingDataChunk(
std::unique_ptr<std::string> dataChunk) {
if (!this->dataChunks.write(std::move(*dataChunk))) {
throw std::runtime_error(
"Error scheduling sending a data chunk to send to the blob service");
}
}
std::unique_ptr<grpc::Status> BlobPutClientReactor::prepareRequest(
blob::PutRequest &request,
std::shared_ptr<blob::PutResponse> previousResponse) {
if (this->state == State::SEND_HOLDER) {
this->request.set_holder(this->holder);
this->state = State::SEND_HASH;
return nullptr;
}
if (this->state == State::SEND_HASH) {
request.set_blobhash(this->hash);
this->state = State::SEND_CHUNKS;
return nullptr;
}
if (previousResponse->dataexists()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
std::string dataChunk;
this->dataChunks.blockingRead(dataChunk);
if (dataChunk.empty()) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
}
request.set_datachunk(dataChunk);
return nullptr;
}
void BlobPutClientReactor::doneCallback() {
this->terminationNotifier->notify_one();
}
grpc::Status BlobPutClientReactor::getStatus() const {
return this->status;
}
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm