Skip to content

Commit

Permalink
Factor out DisplayPlacement from DisplayLayout
Browse files Browse the repository at this point in the history 
* move SwapPrimaryDisplayForTest to display_manager_test_api.h
 (I'm moving primary display stuff to display manager now)

BUG=582491
TEST=no functional change. all test should still pass.
TBR=benwells@chromium.org

Review URL: https://codereview.chromium.org/1679053003

Cr-Commit-Position: refs/heads/master@{#374595}
  • Loading branch information
@mitoshima
mitoshima authored and Commit bot committed Feb 10, 2016
1 parent ebe83e9 commit 95d499b
Show file tree
Hide file tree
Showing 32 changed files with 380 additions and 392 deletions.
126 changes: 58 additions & 68 deletions ash/display/display_layout.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,9 @@

#include "ash/display/display_layout.h"

#include <ostream>

#include "ash/ash_switches.h"
#include "ash/display/display_manager.h"
#include "ash/display/display_pref_util.h"
#include "ash/shell.h"
#include "base/json/json_value_converter.h"
Expand All @@ -30,70 +31,41 @@ const char kMirroredKey[] = "mirrored";
const char kDefaultUnifiedKey[] = "default_unified";
const char kPrimaryIdKey[] = "primary-id";

typedef std::map<DisplayLayout::Position, std::string> PositionToStringMap;
using PositionToStringMap = std::map<DisplayPlacement::Position, std::string>;
using DisplayPlacementMap = std::unordered_map<int64_t, DisplayPlacement>;

const PositionToStringMap* GetPositionToStringMap() {
static const PositionToStringMap* map = CreateToStringMap(
DisplayLayout::TOP, "top",
DisplayLayout::BOTTOM, "bottom",
DisplayLayout::RIGHT, "right",
DisplayLayout::LEFT, "left");
DisplayPlacement::TOP, "top", DisplayPlacement::BOTTOM, "bottom",
DisplayPlacement::RIGHT, "right", DisplayPlacement::LEFT, "left");
return map;
}

std::string ToPositionString(DisplayPlacement::Position position) {
const PositionToStringMap* map = GetPositionToStringMap();
PositionToStringMap::const_iterator iter = map->find(position);
return iter != map->end() ? iter->second : std::string("unknown");
}

bool GetPositionFromString(const base::StringPiece& position,
DisplayLayout::Position* field) {
DisplayPlacement::Position* field) {
if (ReverseFind(GetPositionToStringMap(), position, field))
return true;
LOG(ERROR) << "Invalid position value:" << position;
return false;
}

std::string GetStringFromPosition(DisplayLayout::Position position) {
const PositionToStringMap* map = GetPositionToStringMap();
PositionToStringMap::const_iterator iter = map->find(position);
return iter != map->end() ? iter->second : std::string("unknown");
}

bool GetDisplayIdFromString(const base::StringPiece& position, int64_t* field) {
return base::StringToInt64(position, field);
}

} // namespace

////////////////////////////////////////////////////////////////////////////////
// DisplayLayout

// static
DisplayLayout DisplayLayout::FromInts(int position, int offsets) {
return DisplayLayout(static_cast<Position>(position), offsets);
}

DisplayLayout::DisplayLayout()
: position(RIGHT),
offset(0),
mirrored(false),
#if defined(OS_CHROMEOS)
default_unified(true),
#else
default_unified(false),
#endif
primary_id(gfx::Display::kInvalidDisplayID) {
}

DisplayLayout::DisplayLayout(DisplayLayout::Position position, int offset)
: position(position),
offset(offset),
mirrored(false),
#if defined(OS_CHROMEOS)
default_unified(true),
#else
default_unified(false),
#endif
primary_id(gfx::Display::kInvalidDisplayID) {
// DisplayPlacement
DisplayPlacement::DisplayPlacement(Position p, int o) : position(p), offset(o) {
DCHECK_LE(TOP, position);
DCHECK_GE(LEFT, position);

// Set the default value to |position| in case position is invalid. DCHECKs
// above doesn't stop in Release builds.
if (TOP > position || LEFT < position)
Expand All @@ -102,67 +74,85 @@ DisplayLayout::DisplayLayout(DisplayLayout::Position position, int offset)
DCHECK_GE(kMaxValidOffset, abs(offset));
}

DisplayLayout DisplayLayout::Invert() const {
Position inverted_position = RIGHT;
DisplayPlacement& DisplayPlacement::Swap() {
switch (position) {
case TOP:
inverted_position = BOTTOM;
position = BOTTOM;
break;
case BOTTOM:
inverted_position = TOP;
position = TOP;
break;
case RIGHT:
inverted_position = LEFT;
position = LEFT;
break;
case LEFT:
inverted_position = RIGHT;
position = RIGHT;
break;
}
DisplayLayout ret = DisplayLayout(inverted_position, -offset);
ret.primary_id = primary_id;
return ret;
offset = -offset;
return *this;
}

std::string DisplayPlacement::ToString() const {
return base::StringPrintf("%s, %d", ToPositionString(position).c_str(),
offset);
}

////////////////////////////////////////////////////////////////////////////////
// DisplayLayout

DisplayLayout::DisplayLayout() : DisplayLayout(DisplayPlacement::RIGHT, 0) {}

DisplayLayout::DisplayLayout(DisplayPlacement::Position position, int offset)
: placement(position, offset),
mirrored(false),
default_unified(true),
primary_id(gfx::Display::kInvalidDisplayID) {}

DisplayLayout::~DisplayLayout() {}

// static
bool DisplayLayout::ConvertFromValue(const base::Value& value,
DisplayLayout* layout) {
base::JSONValueConverter<DisplayLayout> converter;
return converter.Convert(value, layout);
converter.Convert(value, layout);

const base::DictionaryValue* dict_value = nullptr;
if (!value.GetAsDictionary(&dict_value) || dict_value == nullptr)
return false;

dict_value->GetInteger(kOffsetKey, &layout->placement.offset);
std::string position;
if (dict_value->GetString(kPositionKey, &position))
GetPositionFromString(position, &layout->placement.position);
return true;
}

// static
bool DisplayLayout::ConvertToValue(const DisplayLayout& layout,
base::Value* value) {
base::DictionaryValue* dict_value = NULL;
if (!value->GetAsDictionary(&dict_value) || dict_value == NULL)
base::DictionaryValue* dict_value = nullptr;
if (!value->GetAsDictionary(&dict_value) || dict_value == nullptr)
return false;

const std::string position_str = GetStringFromPosition(layout.position);
dict_value->SetString(kPositionKey, position_str);
dict_value->SetInteger(kOffsetKey, layout.offset);
dict_value->SetString(kPositionKey,
ToPositionString(layout.placement.position));
dict_value->SetInteger(kOffsetKey, layout.placement.offset);
dict_value->SetBoolean(kMirroredKey, layout.mirrored);
dict_value->SetBoolean(kDefaultUnifiedKey, layout.default_unified);
dict_value->SetString(kPrimaryIdKey, base::Int64ToString(layout.primary_id));
return true;
}

std::string DisplayLayout::ToString() const {
const std::string position_str = GetStringFromPosition(position);
bool unified =
default_unified &&
Shell::GetInstance()->display_manager()->unified_desktop_enabled();

return base::StringPrintf("%s, %d%s%s", position_str.c_str(), offset,
return base::StringPrintf("%s%s%s", placement.ToString().c_str(),
mirrored ? ", mirrored" : "",
unified ? ", unified" : "");
default_unified ? ", default_unified" : "");
}

// static
void DisplayLayout::RegisterJSONConverter(
base::JSONValueConverter<DisplayLayout>* converter) {
converter->RegisterCustomField<Position>(
kPositionKey, &DisplayLayout::position, &GetPositionFromString);
converter->RegisterIntField(kOffsetKey, &DisplayLayout::offset);
converter->RegisterBoolField(kMirroredKey, &DisplayLayout::mirrored);
converter->RegisterBoolField(kDefaultUnifiedKey,
&DisplayLayout::default_unified);
Expand Down
59 changes: 34 additions & 25 deletions ash/display/display_layout.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,42 +20,51 @@ template <typename T> class JSONValueConverter;

namespace ash {

typedef std::vector<int64_t> DisplayIdList;
// An identifier used to manage display layout in DisplayManager /
// DisplayLayoutStore.
using DisplayIdList = std::vector<int64_t>;

// DisplayPlacement specifies where the secondary display is placeed
// relative to |primary| display. In the following example, the secondary
// is placed at the left side of the primary display, with a negative offset.
//
// + +--------+
// offset | | |
// + | S +--------+
// | | |
// +--------+ P |
// | |
// +--------+
//
struct ASH_EXPORT DisplayPlacement {
// To which side the display is positioned relative to the primary display.
enum Position { TOP, RIGHT, BOTTOM, LEFT };
Position position;

struct ASH_EXPORT DisplayLayout {
// Layout options where the secondary display should be positioned.
enum Position {
TOP,
RIGHT,
BOTTOM,
LEFT
};

// Factory method to create DisplayLayout from ints. The |mirrored| is
// set to false and |primary_id| is set to gfx::Display::kInvalidDisplayId.
// Used for persistence and webui.
static DisplayLayout FromInts(int position, int offsets);
// The offset of the position of the secondary display. The offset is
// based on the top/left edge of the primary display.
int offset;

DisplayLayout();
DisplayLayout(Position position, int offset);
DisplayPlacement(Position position, int offset);

DisplayPlacement& Swap();

// Returns an inverted display layout.
DisplayLayout Invert() const WARN_UNUSED_RESULT;
std::string ToString() const;
};

struct ASH_EXPORT DisplayLayout {
DisplayLayout();
DisplayLayout(DisplayPlacement::Position position, int offset);
~DisplayLayout();

// Converter functions to/from base::Value.
static bool ConvertFromValue(const base::Value& value, DisplayLayout* layout);
static bool ConvertToValue(const DisplayLayout& layout, base::Value* value);

// This method is used by base::JSONValueConverter, you don't need to call
// this directly. Instead consider using converter functions above.
static void RegisterJSONConverter(
base::JSONValueConverter<DisplayLayout>* converter);

Position position;

// The offset of the position of the secondary display. The offset is
// based on the top/left edge of the primary display.
int offset;
DisplayPlacement placement;

// True if displays are mirrored.
bool mirrored;
Expand Down
19 changes: 10 additions & 9 deletions ash/display/display_layout_store.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,14 +24,14 @@ DisplayLayoutStore::DisplayLayoutStore() {
int offset = 0;
if (sscanf(value.c_str(), "%c,%d", &layout, &offset) == 2) {
if (layout == 't')
default_display_layout_.position = DisplayLayout::TOP;
default_display_layout_.placement.position = DisplayPlacement::TOP;
else if (layout == 'b')
default_display_layout_.position = DisplayLayout::BOTTOM;
default_display_layout_.placement.position = DisplayPlacement::BOTTOM;
else if (layout == 'r')
default_display_layout_.position = DisplayLayout::RIGHT;
default_display_layout_.placement.position = DisplayPlacement::RIGHT;
else if (layout == 'l')
default_display_layout_.position = DisplayLayout::LEFT;
default_display_layout_.offset = offset;
default_display_layout_.placement.position = DisplayPlacement::LEFT;
default_display_layout_.placement.offset = offset;
}
}
}
Expand Down Expand Up @@ -70,10 +70,11 @@ DisplayLayout DisplayLayoutStore::ComputeDisplayLayoutForDisplayIdList(
DCHECK_NE(layout.primary_id, gfx::Display::kInvalidDisplayID);
// Invert if the primary was swapped. If mirrored, first is always
// primary.
return (layout.primary_id == gfx::Display::kInvalidDisplayID ||
list[0] == layout.primary_id)
? layout
: layout.Invert();
if (layout.primary_id != gfx::Display::kInvalidDisplayID &&
list[0] != layout.primary_id) {
layout.placement.Swap();
}
return layout;
}

void DisplayLayoutStore::UpdateMultiDisplayState(const DisplayIdList& list,
Expand Down
Loading

0 comments on commit 95d499b

Please sign in to comment.