public SimulationView (Context context, SensorManager sensorManager, IWindowManager window)
: base (context)
{
Bounds = new PointF ();
// Get an accelorometer sensor
sensor_manager = sensorManager;
accel_sensor = sensor_manager.GetDefaultSensor (SensorType.Accelerometer);
// Calculate screen size and dpi
var metrics = new DisplayMetrics ();
window.DefaultDisplay.GetMetrics (metrics);
meters_to_pixels_x = metrics.Xdpi / 0.0254f;
meters_to_pixels_y = metrics.Ydpi / 0.0254f;
// Rescale the ball so it's about 0.5 cm on screen
var ball = BitmapFactory.DecodeResource (Resources, Resource.Drawable.Ball);
var dest_w = (int)(BALL_DIAMETER * meters_to_pixels_x + 0.5f);
var dest_h = (int)(BALL_DIAMETER * meters_to_pixels_y + 0.5f);
ball_bitmap = Bitmap.CreateScaledBitmap (ball, dest_w, dest_h, true);
// Load the wood background texture
var opts = new BitmapFactory.Options ();
opts.InDither = true;
opts.InPreferredConfig = Bitmap.Config.Rgb565;
wood_bitmap = BitmapFactory.DecodeResource (Resources, Resource.Drawable.Wood, opts);
wood_bitmap2 = BitmapFactory.DecodeResource (Resources, Resource.Drawable.Wood, opts);
display = window.DefaultDisplay;
particles = new ParticleSystem (this);
}
public static int ToPixels(Context context, float dips)
{
DisplayMetrics metrics = new DisplayMetrics();
var wm = context.GetSystemService(Context.WindowService).JavaCast<IWindowManager>();
wm.DefaultDisplay.GetMetrics(metrics);
return (int) (dips*((float) metrics.DensityDpi/160)); // px = dp * (dpi / 160)
}
void Init(IAttributeSet attrs) {
_headerContainer = new FrameLayout(Context);
if (attrs != null) {
LayoutInflater layoutInflater = LayoutInflater.From(Context);
//初始化状态View
TypedArray a = Context.ObtainStyledAttributes(attrs, Resource.Styleable.PullToZoomListView);
int headViewResId = a.GetResourceId(Resource.Styleable.PullToZoomListView_listHeadView, 0);
if (headViewResId > 0) {
_headerView = layoutInflater.Inflate(headViewResId, null, false);
_headerContainer.AddView(_headerView);
_isHideHeader = false;
} else {
_isHideHeader = true;
}
_isParallax = a.GetBoolean(Resource.Styleable.PullToZoomListView_isHeadParallax, true);
a.Recycle();
}
DisplayMetrics localDisplayMetrics = new DisplayMetrics();
((Activity) Context).WindowManager.DefaultDisplay.GetMetrics(localDisplayMetrics);
_screenHeight = localDisplayMetrics.HeightPixels;
_screenWidth = localDisplayMetrics.WidthPixels;
if (_headerView != null) {
SetHeaderViewSize(_screenWidth, (int) (9.0F * (_screenWidth / 16.0F)));
AddHeaderView(_headerContainer);
}
_scalingRunnable = new ScalingRunnable(this);
base.SetOnScrollListener(this);
}
public void OnSurfaceTextureAvailable(SurfaceTexture surface, int width, int height)
{
nn_surface = new Surface (surface);
RelativeLayout.LayoutParams l;
DisplayMetrics metrics = new DisplayMetrics();
nn_activity.WindowManager.DefaultDisplay.GetMetrics(metrics);
l = new RelativeLayout.LayoutParams(metrics.HeightPixels, metrics.WidthPixels);
l.AddRule(LayoutRules.CenterInParent);
float scale = (metrics.HeightPixels * 1.0f) / (metrics.WidthPixels * 1.0f);
textureview.ScaleX = scale;
textureview.LayoutParameters=l;
try {
nn_mediaplayer= new MediaPlayer();
//String uriPath = "android.resource://"+nn_activity.PackageName+"/raw/Tap5050_About";
nn_mediaplayer.SetDataSource(nn_activity,global::Android.Net.Uri.Parse("android.resource://"+nn_activity.PackageName +"/"+ Resource.Raw.Tap5050_About));
nn_mediaplayer.SetSurface(nn_surface);
nn_mediaplayer.Prepare();
nn_mediaplayer.Prepared+= (object sender, EventArgs e) => {
(sender as MediaPlayer).Start ();
};
nn_mediaplayer.Completion+= (object sender, EventArgs e) => {
(sender as MediaPlayer).SeekTo (0);
(sender as MediaPlayer).Pause ();
};
}catch(Exception e){
Toast.MakeText (nn_activity,"Sorry,Can not play the video",ToastLength.Long).Show();
}
}
protected override void OnCreate (Bundle savedInstanceState)
{
base.OnCreate (savedInstanceState);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.activity_main);
// Get our button from the layout resource,
// and attach an event to it
mBlurringView = (BlurringView) FindViewById(Resource.Id.blurring_view);
View blurredView = FindViewById(Resource.Id.blurred_view);
// Give the blurring view a reference to the blurred view.
mBlurringView.setBlurredView(blurredView);
mImageViews[0] = (ImageView) FindViewById(Resource.Id.image0);
mImageViews[1] = (ImageView) FindViewById(Resource.Id.image1);
mImageViews[2] = (ImageView) FindViewById(Resource.Id.image2);
mImageViews[3] = (ImageView) FindViewById(Resource.Id.image3);
mImageViews[4] = (ImageView) FindViewById(Resource.Id.image4);
mImageViews[5] = (ImageView) FindViewById(Resource.Id.image5);
mImageViews[6] = (ImageView) FindViewById(Resource.Id.image6);
mImageViews[7] = (ImageView) FindViewById(Resource.Id.image7);
mImageViews[8] = (ImageView) FindViewById(Resource.Id.image8);
DisplayMetrics metrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(metrics);
double inches = Math.Sqrt((metrics.WidthPixels * metrics.WidthPixels) + (metrics.HeightPixels * metrics.HeightPixels)) / metrics.Density;
}
public static void Initialize(Context ctx)
{
var wm = ctx.GetSystemService (Context.WindowService).JavaCast<IWindowManager> ();
var displayMetrics = new DisplayMetrics ();
wm.DefaultDisplay.GetMetrics (displayMetrics);
density = displayMetrics.Density;
}
public GridViewAdapter(IEnumerable items, RecyclerView recyclerView, GridView2 gridView, DisplayMetrics displayMetrics)
{
Items = items;
_recyclerView = recyclerView;
Element = gridView;
_displayMetrics = displayMetrics;
_gridView = gridView;
}
public override void OnActivityCreated (Bundle savedInstanceState)
{
base.OnActivityCreated (savedInstanceState);
var metrics = new DisplayMetrics ();
Activity.WindowManager.DefaultDisplay.GetMetrics (metrics);
screenDensity = (int)metrics.DensityDpi;
mediaProjectionManager = (MediaProjectionManager)Activity.GetSystemService (Context.MediaProjectionService);
}
private Tuple<float,float> GetDimensions()
{
var displaymetrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(displaymetrics);
var height = (displaymetrics.HeightPixels/displaymetrics.Density);
var width = displaymetrics.WidthPixels / displaymetrics.Density;
return new Tuple<float, float>(height,width);
}
public AndroidDisplay()
{
var displaymetrics = new DisplayMetrics();
var defaultDisplay = ((Activity)Forms.Context).WindowManager.DefaultDisplay;
defaultDisplay.GetMetrics(displaymetrics);
height = displaymetrics.HeightPixels / displaymetrics.Density;
width = displaymetrics.WidthPixels / displaymetrics.Density;
}
private void PrepareBackgroundManager ()
{
BackgroundManager backgroundManager = BackgroundManager.GetInstance (this.Activity);
backgroundManager.Attach (this.Activity.Window);
mBackgroundTarget = new PicassoBackgroundManagerTarget (backgroundManager);
mDefaultBackground = Resources.GetDrawable (Resource.Drawable.default_background);
mMetrics = new DisplayMetrics ();
this.Activity.WindowManager.DefaultDisplay.GetMetrics (mMetrics);
}
private void GetScreenResolution(Context context)
{
var display = ((Activity)context).WindowManager.DefaultDisplay;
DisplayMetrics metrics = new DisplayMetrics();
display.GetMetrics(metrics);
_width = metrics.WidthPixels;
_height = metrics.HeightPixels;
}
protected override void OnElementChanged(ElementChangedEventArgs<View> e)
{
base.OnElementChanged(e);
var oldMapView = (MapView)Control;
var mapView = new MapView(Context);
mapView.OnCreate(s_bundle);
mapView.OnResume();
SetNativeControl(mapView);
var activity = Context as Activity;
if (activity != null)
{
var metrics = new DisplayMetrics();
activity.WindowManager.DefaultDisplay.GetMetrics(metrics);
foreach (var logic in _logics)
logic.ScaledDensity = metrics.ScaledDensity;
}
if (e.OldElement != null)
{
var oldMapModel = (Map)e.OldElement;
MessagingCenter.Unsubscribe<Map, MoveToRegionMessage>(this, MoveMessageName);
#pragma warning disable 618
if (oldMapView.Map != null)
{
#pragma warning restore 618
#pragma warning disable 618
oldMapView.Map.SetOnCameraChangeListener(null);
#pragma warning restore 618
}
oldMapView.Dispose();
}
var map = NativeMap;
if (map != null)
{
map.SetOnCameraChangeListener(this);
map.UiSettings.ZoomControlsEnabled = Map.HasZoomEnabled;
map.UiSettings.ZoomGesturesEnabled = Map.HasZoomEnabled;
map.UiSettings.ScrollGesturesEnabled = Map.HasScrollEnabled;
map.MyLocationEnabled = map.UiSettings.MyLocationButtonEnabled = Map.IsShowingUser;
SetMapType();
}
#pragma warning disable 618
foreach (var logic in _logics)
logic.Register(oldMapView?.Map, (Map)e.OldElement, NativeMap, Map);
#pragma warning restore 618
MessagingCenter.Subscribe<Map, MoveToRegionMessage>(this, MoveMessageName, OnMoveToRegionMessage, Map);
}
//Scaling image so that it has at least one of the sides be RectSize
private static Bitmap ScaleImage (Bitmap bitmap, DisplayMetrics metrics)
{
int rectSizePx = (int)TypedValue.ApplyDimension (ComplexUnitType.Dip, RectSize, metrics);
float minSize = (int)Math.Min (bitmap.Width, bitmap.Height);
var scaleFactor = rectSizePx / minSize;
int scaledWidth = (int)Math.Floor (scaleFactor * bitmap.Width);
int scaledHeight = (int)Math.Floor (scaleFactor * bitmap.Height);
return Bitmap.CreateScaledBitmap (bitmap, scaledWidth, scaledHeight, false);
}
public static int GetScreenWidth(Context context)
{
IWindowManager wm = context.GetSystemService(Context.WindowService).JavaCast<IWindowManager>();
Display display = wm.DefaultDisplay;
DisplayMetrics metrics = new DisplayMetrics();
display.GetMetrics(metrics);
int width = metrics.WidthPixels;
int height = metrics.HeightPixels;
return width;
}
public static void Initialize(Context context)
{
var wm = context.GetSystemService(Context.WindowService).JavaCast<IWindowManager>();
var displayMetrics = new DisplayMetrics();
wm.DefaultDisplay.GetMetrics(displayMetrics);
density = displayMetrics.Density;
var bg = new TypedValue();
context.Theme.ResolveAttribute(Android.Resource.Attribute.ColorBackground, bg, true);
DefaultBackground = new ColorDrawable(new Color(bg.Data));
}
void getInfo(ImageView v)
{
DisplayMetrics dm = new DisplayMetrics();
this.WindowManager.DefaultDisplay.GetMetrics (dm);
int topOffset = dm.HeightPixels - LL.MeasuredHeight;
int[] origin = new int[2];
v.GetLocationOnScreen(origin);
int x = origin[0];
int y = origin[1] - topOffset;
}
private void MoveIndicatorImage() {
DisplayMetrics metrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics (metrics);
int width = metrics.WidthPixels;
int left = (int)(IndicatorLeft * metrics.Density + 0.5f);
int right = (int)(IndicatorRight * metrics.Density + 0.5f);
if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.JellyBeanMr2) {
expList.SetIndicatorBoundsRelative (width - left, width - right);
} else {
expList.SetIndicatorBounds (width - left, width - right);
}
}
private void InitWidth() {
ivBottomLine = View.FindViewById<ImageView>(Resource.Id.iv_bottom_line);
bottomLineWidth = ivBottomLine.LayoutParameters.Width;
DisplayMetrics dm = new DisplayMetrics();
Activity.WindowManager.DefaultDisplay.GetMetrics(dm);
int screenW = dm.WidthPixels;
offset = (int) ((screenW / num - bottomLineWidth) / 2);
int avg = (int) (screenW / num);
position_one = avg + offset;
}
protected override void OnCreate (Bundle savedInstanceState)
{
base.OnCreate (savedInstanceState);
SetContentView (Resource.Layout.player_activity);
Log.Debug (TAG, "Created");
mMetrics = new DisplayMetrics ();
WindowManager.DefaultDisplay.GetMetrics (mMetrics);
LoadViews ();
SetupController ();
SetupControlsCallbacks ();
StartVideoPlayer ();
UpdateMetadata (true);
}
void Init(IAttributeSet attrs) {
_headerContainer = new FrameLayout(Context);
_zoomContainer = new FrameLayout(Context);
_contentContainer = new FrameLayout(Context);
_rootContainer = new LinearLayout(Context);
_rootContainer.Orientation = Android.Widget.Orientation.Vertical;
if (attrs != null) {
LayoutInflater layoutInflater = LayoutInflater.From(Context);
//初始化状态View
TypedArray a = Context.ObtainStyledAttributes(attrs, Resource.Styleable.PullToZoomScrollView);
int zoomViewResId = a.GetResourceId(Resource.Styleable.PullToZoomScrollView_scrollZoomView, 0);
if (zoomViewResId > 0) {
_zoomView = layoutInflater.Inflate(zoomViewResId, null, false);
_zoomContainer.AddView(_zoomView);
_headerContainer.AddView(_zoomContainer);
}
int headViewResId = a.GetResourceId(Resource.Styleable.PullToZoomScrollView_scrollHeadView, 0);
if (headViewResId > 0) {
_headView = layoutInflater.Inflate(headViewResId, null, false);
_headerContainer.AddView(_headView);
}
int contentViewResId = a.GetResourceId(Resource.Styleable.PullToZoomScrollView_scrollContentView, 0);
if (contentViewResId > 0) {
_contentView = layoutInflater.Inflate(contentViewResId, null, false);
_contentContainer.AddView(_contentView);
}
a.Recycle();
}
DisplayMetrics localDisplayMetrics = new DisplayMetrics();
((Activity) Context).WindowManager.DefaultDisplay.GetMetrics(localDisplayMetrics);
_screenHeight = localDisplayMetrics.HeightPixels;
_zoomWidth = localDisplayMetrics.WidthPixels;
_scalingRunnable = new ScalingRunnable(this);
_rootContainer.AddView(_headerContainer);
_rootContainer.AddView(_contentContainer);
_rootContainer.SetClipChildren(false);
_headerContainer.SetClipChildren(false);
AddView(_rootContainer);
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
SetContentView(Resource.Layout.PullToZoomScrollViewLayout);
ActionBar.SetDisplayHomeAsUpEnabled(true);
scrollView = (PullToZoomScrollViewEx) FindViewById(Resource.Id.scrollView);
DisplayMetrics localDisplayMetrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(localDisplayMetrics);
int mScreenHeight = localDisplayMetrics.HeightPixels;
int mScreenWidth = localDisplayMetrics.WidthPixels;
LinearLayout.LayoutParams localObject = new LinearLayout.LayoutParams(mScreenWidth, (int) (9.0F * (mScreenWidth / 16.0F)));
scrollView.SetHeaderLayoutParams(localObject);
}
private void RunGame()
{
var disp = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(disp);
var initSF = 1 + ((int)disp.DensityDpi / 200);
var dpiScaleFactor = initSF;
var width = Math.Max(disp.WidthPixels, disp.HeightPixels);
var height = Math.Min(disp.WidthPixels, disp.HeightPixels);
float uiZoomFactor = 1f;
while (width / dpiScaleFactor < 800 && dpiScaleFactor > 1)
{
dpiScaleFactor--;
uiZoomFactor = (initSF / dpiScaleFactor);
}
var iPad = ((int)disp.DensityDpi < 200);
var docs = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
CopyAssets("", docs);
FSOEnvironment.ContentDir = Path.Combine(docs, "Content/"); //copied to storage
FSOEnvironment.GFXContentDir = "Content/iOS/"; //in assets
FSOEnvironment.UserDir = docs;
FSOEnvironment.Linux = true;
FSOEnvironment.DirectX = false;
FSOEnvironment.SoftwareKeyboard = true;
FSOEnvironment.SoftwareDepth = true;
FSOEnvironment.UseMRT = false;
FSOEnvironment.UIZoomFactor = uiZoomFactor;
FSOEnvironment.DPIScaleFactor = dpiScaleFactor;
FSO.Files.ImageLoader.UseSoftLoad = false;
//below is just to get blueprint.dtd reading. Should be only thing using relative directories.
Directory.SetCurrentDirectory(Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), "Content/Blueprints/"));
if (File.Exists(Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), "The Sims Online.zip")))
File.Delete(Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), "The Sims Online.zip"));
var start = new GameStartProxy();
start.SetPath(Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), "The Sims Online/TSOClient/"));
TSOGame game = new TSOGame();
new Microsoft.Xna.Framework.GamerServices.GamerServicesComponent(game);
GameFacade.DirectX = false;
World.DirectX = false;
SetContentView((View)game.Services.GetService(typeof(View)));
game.Run();
}
public static GridLength Parse(string source, DisplayMetrics metrics)
{
if(source.ToLower() == "auto")
{
return new GridLength(1, GridUnitType.Auto);
}
if(source == "*")
{
return new GridLength(1, GridUnitType.Star);
}
if(source.EndsWith("*"))
{
return new GridLength(double.Parse(source.Substring(0, source.Length-1)), GridUnitType.Star);
}
return new GridLength(DimensionConverter.StringToDimensionPixelSize(source, metrics));
}
protected override void OnCreate(Bundle bundle)
{
RequestWindowFeature(WindowFeatures.NoTitle);
Window.SetFlags(WindowManagerFlags.Fullscreen, WindowManagerFlags.Fullscreen);
Window.AddFlags(WindowManagerFlags.KeepScreenOn);
LazyResolver<ILoggerService>.Service.Log("OnCreate UserHomeActivity", MessageSeverity.Error);
base.OnCreate(bundle);
SetContentView(Resource.Layout.User_HomePage);
SetViewModel(Container.Locator.UserHomeViewModel);
DisplayMetrics windowSize = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(windowSize);
int availableHeight = windowSize.HeightPixels - 60;
MiddleScreen.Init(availableHeight, windowSize.WidthPixels);
}
public static int StringToDimensionPixelSize(string dimension, DisplayMetrics metrics)
{
InternalDimension internalDimension = StringToInternalDimension(dimension);
float value = internalDimension.Value;
float f = TypedValue.ApplyDimension((ComplexUnitType)(int)internalDimension.Unit, value, metrics);
int res = (int)(f + 0.5f);
if(res != 0)
return res;
if(value == 0)
return 0;
if(value > 0)
return 1;
return -1;
}
public static float GetDPI()
{
if (_dpi == 0)
{
#if ANDROID
var display = Game.Activity.WindowManager.DefaultDisplay;
var metrics = new DisplayMetrics();
display.GetMetrics(metrics);
_dpi = metrics.Density * 160.0f;
#else
//TODO: Implementing GetDPI for all platforms
_dpi = 96;
#endif
}
return _dpi;
}
protected override void OnCreate (Bundle bundle)
{
var metrics = new DisplayMetrics ();
WindowManager.DefaultDisplay.GetMetrics (metrics);
Images.ScreenWidth = metrics.WidthPixels;
FileCache.SaveLocation = CacheDir.AbsolutePath;
base.OnCreate (bundle);
SetContentView (Resource.Layout.Main);
//Retain fragments so don't set home if state is stored.
if (FragmentManager.BackStackEntryCount == 0) {
var productFragment = new ProductListFragment ();
productFragment.ProductSelected += ShowProductDetail;
baseFragment = productFragment.Id;
SwitchScreens (productFragment, false, true);
}
}
public static float GetDPI()
{
if (_dpi == 0)
{
#if ANDROID
var contex = (Activity)CCApplication.SharedApplication.Game.Window.Context;
var display = contex.WindowManager.DefaultDisplay;
var metrics = new DisplayMetrics();
display.GetMetrics(metrics);
_dpi = metrics.Density * 160.0f;
#else
//TODO: Implementing GetDPI for all platforms
_dpi = 96;
#endif
}
return _dpi;
}
private void CreateFont(string fontName, float fontSize, CCRawList<char> charset)
{
if (_paint == null)
{
var display = Game.Activity.WindowManager.DefaultDisplay;
var metrics = new DisplayMetrics();
display.GetMetrics(metrics);
_fontScaleFactor = metrics.ScaledDensity;
_paint = new Paint(PaintFlags.AntiAlias);
_paint.Color = Android.Graphics.Color.White;
_paint.TextAlign = Paint.Align.Left;
// _paint.LinearText = true;
}
_paint.TextSize = fontSize;
var ext = System.IO.Path.GetExtension(fontName);
if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
{
var path = System.IO.Path.Combine(CCContentManager.SharedContentManager.RootDirectory, fontName);
var activity = Game.Activity;
try
{
var typeface = Typeface.CreateFromAsset(activity.Assets, path);
_paint.SetTypeface(typeface);
}
catch (Exception)
{
_paint.SetTypeface(Typeface.Create(fontName, TypefaceStyle.Normal));
}
}
else
{
_paint.SetTypeface(Typeface.Create(fontName, TypefaceStyle.Normal));
}
_fontMetrix = _paint.GetFontMetrics();
}
private void Init(Display display)
{
mScroller = new Scroller(Context);
float density;
if (display != null)
{
DisplayMetrics displayMetrics = new DisplayMetrics();
display.GetMetrics(displayMetrics);
density = displayMetrics.Density;
}
else
{
density = Context.Resources.DisplayMetrics.Density;
}
mDensityAdjustedSnapVelocity = (int)(density * SNAP_VELOCITY_DIP_PER_SECOND);
ViewConfiguration configuration = ViewConfiguration.Get(Context);
mTouchSlop = configuration.ScaledTouchSlop;
mMaximumVelocity = configuration.ScaledMaximumFlingVelocity;
}
private T GetResource <T>(Func <Android.Content.Res.Resources, T> operation, CultureInfo culture = null)
{
Reset();
if (culture == null || CultureInfo.CurrentUICulture.Equals(culture))
{
return(operation(AndroidDevice.Instance.Context.Resources));
}
Configuration conf = AndroidDevice.Instance.Context.Resources.Configuration;
conf.Locale = new Locale(culture.TwoLetterISOLanguageName);
var metrics = new DisplayMetrics();
AndroidDevice.Instance.Context.WindowManager.DefaultDisplay.GetMetrics(metrics);
var resources = new Android.Content.Res.Resources(AndroidDevice.Instance.Context.Assets, metrics, conf);
conf.Locale = new Locale(CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
var retVal = operation(resources);
resources = new Android.Content.Res.Resources(AndroidDevice.Instance.Context.Assets, metrics, conf);
return(retVal);
}
private Tuple <int /*top*/, int /*left*/> GetPos()
{
var displaymetrics = new DisplayMetrics();
host.WindowManager.DefaultDisplay.GetMetrics(displaymetrics);
int screenHeight = displaymetrics.HeightPixels;
var leftPos = (searchWordPos.Left + searchWordPos.Right) / 2
- (int)(MainApp.ThisApp.Resources.GetDimension(
Resource.Dimension.contentpage_legaldefine_popup_width) / 2);
var topPos = searchWordPos.Bottom + Conversion.Dp2Px(10);
var popupHeight = (int)MainApp.ThisApp.Resources.GetDimension(
Resource.Dimension.contentpage_legaldefine_popup_height);
if (topPos + popupHeight > screenHeight)
{
topPos = searchWordPos.Top - popupHeight - Conversion.Dp2Px(15);
}
return(new Tuple <int, int>(leftPos, topPos));
}
public override View GetView(int position, View convertView, ViewGroup parent)
{
ViewHolder viewHolder;
if (convertView == null)
{
convertView = layoutInflater.Inflate(ImagePicker.Resource.Layout.grid_view_image_select, null);
viewHolder = new ViewHolder
{
Image = convertView.FindViewById <ImageView>(ImagePicker.Resource.Id.image_view_image_select),
};
convertView.Tag = viewHolder;
}
else
{
viewHolder = convertView.Tag as ViewHolder;
}
var windowManager = activity.WindowManager;
var metrics = new DisplayMetrics();
windowManager.DefaultDisplay.GetMetrics(metrics);
var size = metrics.WidthPixels / 3;
SetLayoutParams(size);
viewHolder.Image.LayoutParameters.Width = size;
viewHolder.Image.LayoutParameters.Height = size;
global::Android.Net.Uri uri = global::Android.Net.Uri.FromFile(new File(arrayList[position].Path));
Glide.With(context).Load(uri).Into(viewHolder.Image);
return(convertView);
}
internal void RaiseNativeSizeChanged()
{
var display = (ContextHelper.Current as Activity)?.WindowManager?.DefaultDisplay;
var fullScreenMetrics = new DisplayMetrics();
// To get the real size of the screen, we should use GetRealMetrics
// GetMetrics or Resources.DisplayMetrics return the usable metrics, ignoring the bottom rounded space on device like LG G7 ThinQ for example
display?.GetRealMetrics(outMetrics: fullScreenMetrics);
var newBounds = ViewHelper.PhysicalToLogicalPixels(new Rect(0, 0, fullScreenMetrics.WidthPixels, fullScreenMetrics.HeightPixels));
var statusBarHeight = GetLogicalStatusBarHeight();
var navigationBarHeight = GetLogicalNavigationBarHeight();
var newVisibleBounds = new Rect(
x: newBounds.X,
y: newBounds.Y + statusBarHeight,
width: newBounds.Width,
height: newBounds.Height - statusBarHeight - navigationBarHeight
);
var applicationView = ApplicationView.GetForCurrentView();
if (applicationView != null && applicationView.VisibleBounds != newVisibleBounds)
{
applicationView.SetCoreBounds(newVisibleBounds);
}
if (Bounds != newBounds)
{
Bounds = newBounds;
RaiseSizeChanged(
new WindowSizeChangedEventArgs(
new Windows.Foundation.Size(Bounds.Width, Bounds.Height)
)
);
}
}
public override void OnResume()
{
base.OnResume();
if (Sections.Any() && (_index > 0 || _top < -1))
{
int sectionIndex, cellIndex;
CellAdapter.GetSectionAndIndex(Sections, _index, out sectionIndex, out cellIndex);
ScrollToCell(sectionIndex, cellIndex, false, _top);
}
SelectedIndex = _selectedIndex;
if (PopoverFragment.Instance == null)
{
return;
}
var metrics = new DisplayMetrics();
DroidFactory.MainActivity.WindowManager.DefaultDisplay.GetMetrics(metrics);
var width = (int)(metrics.WidthPixels * .6 + 16 * DroidFactory.DisplayScale);
var height = LinearLayout.LayoutParams.WrapContent;
PopoverFragment.Instance.Dialog.Window.SetLayout(width, height);
}
async public void StartAnimationLoop(AnimationDirection direction, string designType, int minSize, int maxSize, float duration)
{
if (!String.IsNullOrEmpty(designType) && designType.Equals(Strings.DesignTypes.design_type_none, StringComparison.InvariantCultureIgnoreCase))
{
EndAnimation(AnimationEnding.collapse, 0); return;
}
DisplayMetrics displayMetrics = new DisplayMetrics();
Activity.WindowManager.DefaultDisplay.GetMetrics(displayMetrics);
Animating = true;
Random random = new Random();
//Queue q = new Queue();
while (Animating)
{
var size = random.Next(minSize, maxSize);
var y = random.Next(displayMetrics.HeightPixels);
var view = new View(Activity);
view.LayoutParameters = new LinearLayout.LayoutParams(size, size);
view.SetX(-size);
view.SetY(y);
customView(view, size / 2, GetColor(random, designType));
Parent.AddView(view, view.LayoutParameters);
var o = ObjectAnimator.OfFloat(view, "x", displayMetrics.WidthPixels);
o.SetInterpolator(new LinearInterpolator());
o.SetDuration((long)duration);//miliseconds
o.Start();
o.AnimationEnd += (sender, e) =>
{
//Parent.RemoveView(view);
};
await System.Threading.Tasks.Task.Delay(TimeSpan.FromMilliseconds(130));
}
}
public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
View rootView = inflater.Inflate(Resource.Layout.fragment_list_view_example, container, false);
this.listView = (RadListView)rootView.FindViewById(Resource.Id.listView).JavaCast <RadListView>();
ArrayList dataSource = new ArrayList();
EmailMessage message = new EmailMessage();
message.title = "Tech news";
message.content = "Here is your daily LinkedIn feed with news about .NET, Java, iOS and more...";
dataSource.Add(message);
message = new EmailMessage();
message.title = "Awaiting Payment";
message.content = "Monthly bills summary: water supply, electricity, earth gas...";
dataSource.Add(message);
message = new EmailMessage();
message.title = "Greetings from Hawai";
message.content = "Hey Betty, we've just arrived! What a flight!...";
dataSource.Add(message);
this.listView.SetAdapter(new ListViewSwipeActionsMultipleAdapter(dataSource));
sap = new SwipeActionsBehavior();
DisplayMetrics dp = this.Resources.DisplayMetrics;
this.sap = new SwipeActionsBehavior();
this.sap.SetSwipeThresholdEnd((int)dp.Density * 250);
this.sap.SetSwipeThresholdStart((int)dp.Density * 250);
sap.AddListener(this);
this.listView.AddBehavior(sap);
return(rootView);
}
private void ChangeVideoSize(int width, int height)
{
DisplayMetrics metrics = new DisplayMetrics();
RelativeLayout.LayoutParams layoutParams;
IWindowManager manager = ApplicationContext.GetSystemService(Context.WindowService).JavaCast <IWindowManager>();
manager.DefaultDisplay.GetMetrics(metrics);
float rotation = 90.0f;
layoutParams = new RelativeLayout.LayoutParams(metrics.HeightPixels, metrics.WidthPixels);
float scale = (width * 1.0f) / (height * 1.0f);
_textureView.Rotation = rotation;
_textureView.ScaleX = scale;
layoutParams.AddRule(LayoutRules.CenterInParent, -1);
_textureView.LayoutParameters = layoutParams;
_videoSizeSetupDone = true;
}
// Gets a display metrics object for calculating display dimensions
internal static DisplayMetrics GetDisplayMetrics()
{
if (s_displayMetrics == null)
{
if (s_windowManager == null)
{
s_windowManager = Application.Context?.GetSystemService(Context.WindowService)?.JavaCast <IWindowManager>();
}
if (s_windowManager == null)
{
s_displayMetrics = Application.Context?.Resources?.DisplayMetrics;
}
else
{
s_displayMetrics = new DisplayMetrics();
s_windowManager.DefaultDisplay.GetMetrics(s_displayMetrics);
}
}
return(s_displayMetrics);
}
void Init(IAttributeSet attrs)
{
_headerContainer = new FrameLayout(Context);
if (attrs != null)
{
LayoutInflater layoutInflater = LayoutInflater.From(Context);
//初始化状态View
TypedArray a = Context.ObtainStyledAttributes(attrs, Resource.Styleable.PullToZoomListView);
int headViewResId = a.GetResourceId(Resource.Styleable.PullToZoomListView_listHeadView, 0);
if (headViewResId > 0)
{
_headerView = layoutInflater.Inflate(headViewResId, null, false);
_headerContainer.AddView(_headerView);
_isHideHeader = false;
}
else
{
_isHideHeader = true;
}
_isParallax = a.GetBoolean(Resource.Styleable.PullToZoomListView_isHeadParallax, true);
a.Recycle();
}
DisplayMetrics localDisplayMetrics = new DisplayMetrics();
((Activity)Context).WindowManager.DefaultDisplay.GetMetrics(localDisplayMetrics);
_screenHeight = localDisplayMetrics.HeightPixels;
_screenWidth = localDisplayMetrics.WidthPixels;
if (_headerView != null)
{
SetHeaderViewSize(_screenWidth, (int)(9.0F * (_screenWidth / 16.0F)));
AddHeaderView(_headerContainer);
}
_scalingRunnable = new ScalingRunnable(this);
base.SetOnScrollListener(this);
}
// Gets a display metrics object for calculating display dimensions
private static DisplayMetrics GetDisplayMetrics(Context context)
{
if (s_displayMetrics == null)
{
if (s_windowManager == null)
{
s_windowManager = context.GetSystemService(Context.WindowService)?.JavaCast <IWindowManager>();
}
if (s_windowManager == null)
{
s_displayMetrics = context.Resources?.DisplayMetrics;
}
else
{
s_displayMetrics = new DisplayMetrics();
s_windowManager.DefaultDisplay.GetMetrics(s_displayMetrics);
}
}
return(s_displayMetrics);
}
void ConfigurationChanged(object sender, EventArgs e)
{
if (IsDuo)
{
_helper?.Update();
}
bool wasLandscape = IsLandscape;
Update();
bool screenChanged = false;
if (wasLandscape != IsLandscape)
{
screenChanged = true;
}
if (_mainActivity != null)
{
using (DisplayMetrics display = _mainActivity.Resources.DisplayMetrics)
{
var scalingFactor = display.Density;
_pixelScreenSize = new Size(display.WidthPixels, display.HeightPixels);
var newSize = new Size(_pixelScreenSize.Width / scalingFactor, _pixelScreenSize.Height / scalingFactor);
if (newSize != ScaledScreenSize)
{
ScaledScreenSize = newSize;
screenChanged = true;
}
}
}
if (screenChanged)
{
_onScreenChangedEventManager.HandleEvent(this, e, nameof(OnScreenChanged));
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
GridView gridview = FindViewById <GridView>(Resource.Id.gridview);
mCalendar = DateTime.Now;
mToday[0] = mCalendar.Day;
mToday[1] = mCalendar.Month;
mToday[2] = mCalendar.Year;
// get display metrics
DisplayMetrics metrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(metrics);
// set adapter
gridview = (GridView)FindViewById(Resource.Id.gridview);
gridview.Adapter = new MonthAdapter(this, mToday[1], mToday[2], metrics);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_image_browser);
mPathList = Intent.GetStringArrayListExtra("pathList").ToList();
mMsgIdList = Intent.GetStringArrayListExtra("idList").ToList();
mViewPager = FindViewById <ImgBrowserViewPager>(Resource.Id.img_browser_viewpager);
DisplayMetrics dm = Resources.DisplayMetrics;
mWidth = dm.WidthPixels;
mHeight = dm.HeightPixels;
int maxMemory = (int)(Java.Lang.Runtime.GetRuntime().MaxMemory());
int cacheSize = maxMemory / 4;
mCache = new LruCache(cacheSize);
mViewPager.Adapter = new CustomPagerAdapter(this);
InitCurrentItem();
}
/// <summary>
/// Returns the available screensize, including status bar and navigation bar </summary>
public static Size getScreenSize(Activity context)
{
Display display = context.WindowManager.DefaultDisplay;
int realWidth;
int realHeight;
if ((int)Build.VERSION.SdkInt >= 17)
{
DisplayMetrics realMetrics = new DisplayMetrics();
display.GetRealMetrics(realMetrics);
realWidth = realMetrics.WidthPixels;
realHeight = realMetrics.HeightPixels;
}
else if ((int)Build.VERSION.SdkInt >= 14)
{
// try
// {
// Method mGetRawH = typeof(Display).GetMethod("getRawHeight");
// Method mGetRawW = typeof(Display).GetMethod("getRawWidth");
// realWidth = (int?) mGetRawW.invoke(display);
// realHeight = (int?) mGetRawH.invoke(display);
// }
// catch (Exception e)
// {
//this may not be 100% accurate, but it's all we've got
realWidth = display.Width;
realHeight = display.Height;
// Log.e("Display Info", "Couldn't use reflection to get the real display metrics.");
// }
}
else
{
//This should be close, as lower API devices should not have window navigation bars
realWidth = display.Width;
realHeight = display.Height;
}
return(new Size(realWidth, realHeight));
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
App.ScreenWidth = (int)Resources.DisplayMetrics.WidthPixels; // real pixels
App.ScreenHeight = (int)Resources.DisplayMetrics.HeightPixels; // real pixels
var metrics = new DisplayMetrics();
this.WindowManager.DefaultDisplay.GetMetrics(metrics);
App.Ydpi = metrics.Ydpi;
App.Xdpi = metrics.Xdpi;
LoadApplication(new App());
var userSelectedCulture = new CultureInfo("el-GR");
Thread.CurrentThread.CurrentCulture = userSelectedCulture;
}
public static Bitmap LoadBitmap(Activity activity, String FileName)
{
int rotation = 0;
try
{
ExifInterface exif = new ExifInterface(FileName);
rotation = GlobalHelpers.getRotateDegreeFromOrientation(exif.GetAttributeInt(
ExifInterface.TagOrientation,
(int)Android.Content.Res.Orientation.Undefined));
}
catch (IOException ex)
{
ex.PrintStackTrace();
}
Bitmap image;
int width, height;
DisplayMetrics displayMetrics = new DisplayMetrics();
activity.WindowManager.DefaultDisplay.GetRealMetrics(displayMetrics);
Matrix matrix = new Matrix();
matrix.PostRotate(90);
if (rotation == 90 || rotation == 270)
{
width = displayMetrics.HeightPixels;
height = displayMetrics.WidthPixels;
image = GlobalHelpers.decodeSampledBitmapFromFile(FileName, width, height);
}
else
{
width = displayMetrics.WidthPixels;
height = displayMetrics.HeightPixels;
image = GlobalHelpers.decodeSampledBitmapFromFile(FileName, width, height);
}
return(Bitmap.CreateBitmap(image, 0, 0, image.Width, image.Height, matrix, true));
}
void CentrarMapa()
{
LatLng centro;
double zoom;
if (_posiciones != null && _posiciones.Count >= 2)
{
var primera = _posiciones.First();
var ultima = _posiciones.Last();
var displayMetrix = new DisplayMetrics();
Activity.WindowManager.DefaultDisplay.GetMetrics(displayMetrix);
var pixelWidth = displayMetrix.WidthPixels;
var GLOBE_WIDTH = 256;
var west = primera.Coordenada.Longitud;
var east = ultima.Coordenada.Longitud;
var angle = east - west;
if (angle < 0)
{
angle += 360;
}
zoom = Math.Round(Math.Log(pixelWidth * 360 / angle / GLOBE_WIDTH) / Math.Log(2));
centro = new LatLng(primera.Coordenada.Latitud, primera.Coordenada.Longitud);
}
else
{
centro = LeonGuanajuato;
zoom = 8.0f;
}
_mapa.AnimateCamera(CameraUpdateFactory.NewLatLngZoom(centro, (float)zoom));
}
protected override void OnActivityResult(int requestCode, [GeneratedEnum] Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
if (requestCode == VideoInputServiceConnection.PROJECTION_REQ_CODE && resultCode == Result.Ok)
{
try
{
DisplayMetrics metrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(metrics);
float percent = 0f;
float hp = ((float)metrics.HeightPixels) - 1920f;
float wp = ((float)metrics.WidthPixels) - 1080f;
if (hp < wp)
{
percent = (((float)metrics.WidthPixels) - 1080f) / ((float)metrics.WidthPixels);
}
else
{
percent = (((float)metrics.HeightPixels) - 1920f) / ((float)metrics.HeightPixels);
}
metrics.HeightPixels = (int)(((float)metrics.HeightPixels) - (metrics.HeightPixels * percent));
metrics.WidthPixels = (int)(((float)metrics.WidthPixels) - (metrics.WidthPixels * percent));
data.PutExtra(ExternalVideoInputManager.FLAG_SCREEN_WIDTH, metrics.WidthPixels);
data.PutExtra(ExternalVideoInputManager.FLAG_SCREEN_HEIGHT, metrics.HeightPixels);
data.PutExtra(ExternalVideoInputManager.FLAG_SCREEN_DPI, (int)metrics.Density);
data.PutExtra(ExternalVideoInputManager.FLAG_FRAME_RATE, DEFAULT_SHARE_FRAME_RATE);
SetVideoConfig(metrics.WidthPixels, metrics.HeightPixels);
_service.SetExternalVideoInput(ExternalVideoInputManager.TYPE_SCREEN_SHARE, data);
}
catch (RemoteException e)
{
e.PrintStackTrace();
}
}
}
/**
* One of DEFAULT, or LARGE.
*/
public void setSize(int size)
{
if (size != MaterialProgressDrawable.LARGE && size != MaterialProgressDrawable.DEFAULT)
{
return;
}
DisplayMetrics metrics = Resources.DisplayMetrics;
if (size == MaterialProgressDrawable.LARGE)
{
mCircleHeight = mCircleWidth = (int)(CIRCLE_DIAMETER_LARGE * metrics.Density);
}
else
{
mCircleHeight = mCircleWidth = (int)(CIRCLE_DIAMETER * metrics.Density);
}
// force the bounds of the progress circle inside the circle view to
// update by setting it to null before updating its size and then
// re-setting it
mCircleView.SetImageDrawable(null);
mProgress.updateSizes(size);
mCircleView.SetImageDrawable(mProgress);
}
protected override void OnElementChanged(ElementChangedEventArgs <Frame> e)
{
base.OnElementChanged(e);
if (e.NewElement != null)
{
double borderWidth = FrameProps.GetBorderWidth(e.NewElement);
Color borderColor = e.NewElement.BorderColor;
if (borderWidth != (double)FrameProps.BorderWidthProperty.DefaultValue && borderColor.IsDefault == false)
{
GradientDrawable _backgroundDrawable = (GradientDrawable)typeof(Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer)
.GetField(nameof(_backgroundDrawable), BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(this);
DisplayMetrics displayMetrics = Context.Resources.DisplayMetrics;
int borderWidthInPixel = (int)Math.Round(borderWidth * (displayMetrics.Xdpi / (int)DisplayMetricsDensity.Default));
_backgroundDrawable.SetStroke(borderWidthInPixel, borderColor.ToAndroid());
}
}
}
public static int GetSoftButtonsBarSize(Activity activity)
{
// getRealMetrics is only available with API 17 and +
if (Build.VERSION.SdkInt < BuildVersionCodes.JellyBeanMr1)
{
return(0);
}
var orientation = activity.Resources.Configuration.Orientation;
var metrics = new DisplayMetrics();
activity.WindowManager.DefaultDisplay.GetMetrics(metrics);
var usableHeight = orientation == Orientation.Landscape ? metrics.WidthPixels : metrics.HeightPixels;
var realMetrics = new DisplayMetrics();
activity.WindowManager.DefaultDisplay.GetRealMetrics(realMetrics);
var realHeight = orientation == Orientation.Landscape ? realMetrics.WidthPixels : realMetrics.HeightPixels;
if (realHeight > usableHeight)
{
return(realHeight - usableHeight);
}
return(0);
}
// Private Methods /////////////////////////////////////////////////////////
private void Init(Context context)
{
try
{
DisplayMetrics displayMetrics = context.Resources.DisplayMetrics;
mHandleRadius = HandleUtil.getTargetRadius(context);
mSnapRadius = TypedValue.ApplyDimension(ComplexUnitType.Dip, SNAP_RADIUS_DP, displayMetrics);
mBorderPaint = PaintUtil.newBorderPaint(context);
mGuidelinePaint = PaintUtil.newGuidelinePaint();
mBackgroundPaint = PaintUtil.newBackgroundPaint(context);
mCornerPaint = PaintUtil.newCornerPaint(context);
// Sets the values for the corner sizes
mCornerOffset = TypedValue.ApplyDimension(ComplexUnitType.Dip, DEFAULT_CORNER_OFFSET_DP, displayMetrics);
mCornerExtension = TypedValue.ApplyDimension(ComplexUnitType.Dip, DEFAULT_CORNER_EXTENSION_DP, displayMetrics);
mCornerLength = TypedValue.ApplyDimension(ComplexUnitType.Dip, DEFAULT_CORNER_LENGTH_DP, displayMetrics);
// Sets guidelines to default until specified otherwise
mGuidelines = CropImageView.DEFAULT_GUIDELINES;
}
catch (Exception ex)
{
ex.ToString();
}
}
int GetStatusBarHeight()
{
const int DefaultStatusBarHeight = 24;
int resourceId = Context.Resources.GetIdentifier("status_bar_height", "dimen", "android");
if (resourceId <= 0)
{
return(DefaultStatusBarHeight);
}
var pixelSize = Context.Resources.GetDimensionPixelSize(resourceId);
if (_mainActivity == null)
{
return(DefaultStatusBarHeight);
}
var metrics = new DisplayMetrics();
_mainActivity.WindowManager.DefaultDisplay.GetRealMetrics(metrics);
return((int)(pixelSize / metrics.Density));
}
/// <summary>
/// Calculates and set initial parameters
/// </summary>
private void InitializeParameters()
{
// default if none provided. This is depreciated though, so need a work around for the class library.
mBackgroundColor = mBackgroundColor != 0 ? mBackgroundColor : Resources.GetColor(Resource.Color.showcase_defaultcolour);
if (mTitleGravity != -2)
{
mTitleGravity = mTitleGravity >= 0 ? mTitleGravity : (int)GravityFlags.Center;
}
// default if none provided.
mTitleStyle = mTitleStyle != 0 ? mTitleStyle : Resource.Style.ShowcaseDefaultTitleStyle;
DisplayMetrics displayMetrics = new DisplayMetrics();
mActivity.WindowManager.DefaultDisplay.GetMetrics(displayMetrics);
int deviceWidth = displayMetrics.WidthPixels;
int deviceHeight = displayMetrics.HeightPixels;
mCenterX = deviceWidth / 2;
mCenterY = deviceHeight / 2;
mSharedPreferences = mActivity.GetSharedPreferences(PREF_NAME, FileCreationMode.Private);
}
public static int StringToDimensionPixelSize(string dimension, DisplayMetrics metrics)
{
InternalDimension internalDimension = StringToInternalDimension(dimension);
float value = internalDimension.Value;
float f = TypedValue.ApplyDimension((ComplexUnitType)(int)internalDimension.Unit, value, metrics);
int res = (int)(f + 0.5f);
if (res != 0)
{
return(res);
}
if (value == 0)
{
return(0);
}
if (value > 0)
{
return(1);
}
return(-1);
}
private void addDaysinCalendar(LayoutParams buttonParams, Context context,
DisplayMetrics metrics)
{
int engDaysArrayCounter = 0;
for (int weekNumber = 0; weekNumber < 6; ++weekNumber)
{
for (int dayInWeek = 0; dayInWeek < 7; ++dayInWeek)
{
Button day = new Button(context);
day.SetTextColor(Color.ParseColor(color_grey));
day.SetBackgroundColor(Color.Transparent);
day.LayoutParameters = buttonParams;
day.SetTextSize(ComplexUnitType.Dip, (int)metrics.Density * 8);
day.SetSingleLine();
days[engDaysArrayCounter] = day;
weeks[weekNumber].AddView(day);
++engDaysArrayCounter;
}
}
}
public static (Int32 width, Int32 height) GetScreenPixelSize(IWindowManager manager)
{
if (Build.VERSION.SdkInt < BuildVersionCodes.R)
{
DisplayMetrics displayMetrics = new DisplayMetrics();
#pragma warning disable CS0618
manager.DefaultDisplay.GetMetrics(displayMetrics);
#pragma warning restore CS0618
return(displayMetrics.WidthPixels, displayMetrics.HeightPixels);
}
WindowMetrics windowMetrics = manager.CurrentWindowMetrics;
WindowInsets windowInsets = windowMetrics.WindowInsets;
Int32 mask = WindowInsets.Type.NavigationBars() | WindowInsets.Type.DisplayCutout();
Insets insets = windowInsets.GetInsetsIgnoringVisibility(mask);
Size insetsSize = new Size(insets.Right + insets.Left, insets.Top + insets.Bottom);
Rect bounds = windowMetrics.Bounds;
return(bounds.Width() - insetsSize.Width, bounds.Height() - insetsSize.Height);
}
protected override async void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
_name = Intent.Extras.GetString("name");
_id = Intent.Extras.GetInt("id");
SetContentView(Resource.Layout.MainPage);
SetSupportActionBar(FindViewById <Android.Support.V7.Widget.Toolbar>(Resource.Id.toolbar));
SupportActionBar.Title = _name;
_exRecyclerView = FindViewById <ExRecyclerView>(Resource.Id.MainPageRecyclerView);
var disp = WindowManager.DefaultDisplay;
var met = new DisplayMetrics();
disp.GetMetrics(met);
var heightm = met.HeightPixels;
var widthm = met.WidthPixels;
_exRecyclerView.ViewLayoutManager = new GridLayoutManager(this, heightm > widthm ? 2 : 3);
_refresher = FindViewById <ScrollChildSwipeRefreshLayout>(Resource.Id.MainPageRefresher);
_refresher.SetColorSchemeResources(Resource.Color.MediumVioletRed);
_refresher.Refresh += async delegate { await Refresh(); };
_refresher.Post(() => _refresher.Refreshing = true);
await Refresh();
}
