Monday, September 25, 2017

Ground Breaking Windows Tech Support



All things considered, even with the Windows OS bragging of a stunning extent items, one can't simply get rid of the need of finding that tad bit of help once in a while. Be that as it may, on a brighter note one need stress likewise in light of the fact that there is a decent lion's share of PC clients out there who require help with request to get their Windows OS up and running with no glitches at all. Further, additionally for the basic reason that toward the day's end the need is to manage windows OS issues which are not all that shockingly outside our ability to grasp.
However, notwithstanding all that and that's only the tip of the iceberg, it likewise winds up being the situation continuously where one needs to have an extraordinary level of information to completely comprehend everything as well as get superlative Microsoft OS Support. A circumstance wherein head technical support elements tends to venture into the photo for sure.
World renowned solution for a decent lion's share of Microsoft Support issues
The Windows specialized help originating from a chief association, for example, PCCare247 winds up going far in diagnosing as well as so far as that is concerned and settling an astounding dominant part of issues which tend to torment a working framework. In a perfect world, one of those circumstances where top of the line Microsoft Windows Support winds up going far in guaranteeing not just PC clients would have their archives spared, moved down yet at a similar case wouldn't need to stress over losing any delicate information anytime.
PC tenderfoots can cool off
In the event that you are a PC client who is battling with sudden slamming of the Windows OS; you can wind up taking a load off; for PCCare247 winds up doing the safeguard demonstration. The head technical support element does everything conceivable inside its capacity to redress issues, for example, terrible memory, BIOS settings, programming blunders, infections, malwares, spywares and a scope of issues which plan to play devastation with the soundness of your PC. To put it plainly, as it winds up being the situation such windows accidents may arrive the framework into a lethal stage where redress would should be done by specialists expeditiously.

Also visit my previous post here : Different Types of Windows Support

Wednesday, August 30, 2017

Different Types of Windows Support

The PC has turned out to be such an imperative piece of our cutting edge experience that it has turned out to be practically difficult to live it. Tragically, there are times when we keep running into an issue with our PC and our lives come to a standstill.

When we are stood up to by an issue with our PCs, we are confronted with different choices. Would it be advisable for us to attempt to settle everything without anyone else's input? Would it be advisable for us to take it to a repair shop or bring somebody over to settle it? Or, then again would it be advisable for us to attempt bring in Windows Support?

On the off chance that you need to attempt your hand at settling the issue without anyone else's input, you should visit the official Windows Support page. The official page will furnish you with content aides that you can use to attempt and resolve the issue independent from anyone else. You could likewise attempt scan for an answer for your issue on online gathering. Notwithstanding your decision, you'll get a content guide that will give you point by point directions on the most proficient method to determine the issue for yourself. The disadvantage here is that you will be relied upon to be comfortable with PCs and comprehend what every one of the terms mean.

Something else you could do is convey your PC to the closest administration place for repair. The general population at the administration focus will either repair your PC at that moment or they will take your PC for you and will return it in two or three days. The most clear issue with this sort of Windows Technical Support other than the way that you should drag your PC the distance to an administration focus is that this will take up some time. On the off chance that the administration focus isn't confirmed to repair your gadget, at that point there is a decent change they will decline to repair it.

You can likewise attempt to call a repair man to your home. The repairman is normally a specialist at giving Windows Tech Support and can resolve your issues at home without the need to convey your PC to an administration focus. The main issue here is that the repairman will come during a period that best suits him and on the off chance that you keep running into an issue late during the evening, at that point it would be practically inconceivable for you to get Windows Help and Support.

Bring in Windows Technical Support consolidates the common sense of not bearing your PC with the comfort of having day in and day out master technical support. The Technical Support specialists contracted by organizations, for example, Tech Support Mart can even give you Hotmail Support.All you have to do is enable them impermanent access to your PC and after that you can kick back and watch them settle your issue for you. The main disadvantage with bring in help is that you need to ensure that the organization you are working with has a decent notoriety. This can be checked by means of a speedy online pursuit.

The creator is a specialized help officer for Tech Support Mart with years of involvement in giving Windows Contact Number.

Also, visit my previous post here : How to Restart your App Programmatically

Monday, July 31, 2017

How to Restart your App Programmatically

For some apps (especially games) it is not uncommon for the app to get into a state where it needs to restart – perhaps after a license update, after installing downloadable content, its caches have become corrupt or unwieldy, or for any other reason where the app needs to refresh state from scratch. In earlier releases, your only option would have been to prompt the user to close and relaunch, or to call CoreApplication.Exit – and both options provide sub-optimal user experience.
We have therefore introduced a new API that enables an app to request immediate termination and restart, and to pass arbitrary arguments into the fresh instance. In this post, we’ll look at how this works and how you can build it into your app. This is available now in Insider builds from Build 16226 onwards, along with the corresponding SDK.
Here’s a sample app, called TestRestart.
The app provides a ListView of cities on the left, the currently-selected city on the right and a TextBox for providing arguments to the app when it is restarted. When the user taps the Request Restart button, the app will terminate and restart itself, passing in the supplied arguments. The new API, RequestRestartAsync, is exposed as a static method on the CoreApplication object. It takes a string parameter, which can be any string value you like – including input from the user or another external entity. If you do choose to accept input in this way, it is your responsibility to validate it correctly to make sure it conforms to whatever constraints you choose to impose. You should do this validation on input, before passing it to RequestRestartAsync. In this sample app, we’re expecting the user to type in the name of a city.
async private void DoRestartRequest()
{
    bool isValidPayload = false;
    string payload = restartArgs.Text;
    if (!string.IsNullOrEmpty(payload))
    {
        foreach (ImageViewModel imageItem in imageListView.Items)
        {
            if (imageItem.Name == payload)
            {
                isValidPayload = true;
                break;
            }
        }
    }

    if (isValidPayload)
    {
        AppRestartFailureReason result =
            await CoreApplication.RequestRestartAsync(payload);
        if (result == AppRestartFailureReason.NotInForeground ||
            result == AppRestartFailureReason.RestartPending ||
            result == AppRestartFailureReason.Other)
        {
            Debug.WriteLine("RequestRestartAsync failed: {0}", result);
        }
    }
}
To mitigate privacy concerns, an app is only permitted to restart itself if it is in the foreground at the time it makes the request. When the app restarts, it restarts with normal UI – that is, as a normal foreground window. If we were to permit a background task or minimized app to restart, the result would be unexpected to the user. This is why the API is framed as a request. If the request is denied, the app would need to handle the failure – perhaps by waiting until it is in the foreground and trying again. If you were to request a restart and then through some twist of logic managed to request it again before the system started the operation, then you’d get the RestartPending result, although this is an edge case. You’re unlikely to ever get the other result – unless something goes wrong in the platform.
Note that this is the only significant constraint, but you should use this API carefully. For example, you probably should not use it if your app was not originally launched by the user – for example, if it was launched as the result of a share or picker operation. Restarting in the middle of one of those contract operations would certainly confuse the user.
If the request is granted, the app is terminated and then restarted. There are many different ways to activate an app: in addition to a regular launch activation, apps can choose to support file activation, protocol activation, share or picker activation and so on. The list is documented here. For the restart case, the app will be activated as a regular launch – just as if the user had closed the app manually and tapped its tile to launch it again – but including the arbitrary arguments supplied earlier (if any).
In your App class, you should handle this by overriding the OnActivated method. Test the ActivationKind, and if it’s ActivationKind.Launch, then the incoming IActivatedEventArgs will be a LaunchActivatedEventArgs. From this, you can get hold of the incoming activation arguments. For a regular user-initiated launch, the Arguments will be empty, so if it’s not empty you could simply infer that this is a restart activation. You can also check the PreviousExecutionState, which for a restart operation will be set to Terminated.
Although the arguments might have originated from an untrusted source (eg, the user), you should have done the validation before requesting restart. If so, you can consider them trustworthy when you receive them in OnActivated.

windows support number
windows support 
windows helpline number
windows helpline 

Thursday, July 27, 2017

windows 10 related some points

Hello,  everyone,  am shubham singh. I say some point related to windows10. Windows is very popular but windows10 is not good compared to the previous version.in windows10 have many updates and many feuste but windows 10 have many updates if you are using windows 10 then face this type of problem. And windows 10 are not required antivirus in windows defender are very good antivirus in this antivirus as compared. Windows 10 is very nice windows but in this windows only one problem updates I am say some points. How to stop windows 10 updates.
1.   Use the Windows key + R keyboard shortcut to open the Run command.
2.   Type gpedit.msc and click OK to open the Local Group Policy Editor.
3.   Browse the following path:
Computer Configuration\Administrative Templates\Windows Components\Windows Update
4.   Go right side, double-click the Configure Automatic Updates policy.
5.   Go left side, check the Enabled option to enable the policy.
6.   Under Options, you'll find a number of ways to configure automatic updates, including:
1.   2 - "Notify for download and notify for install."
2.   3 - "Auto download and notify for install."
3.   4 - "Auto download and schedule the install."
4.   5 - "Allow local admin to choose setting."

You should select the update option you want to configure. If you are select 
option four, you can specify exactly when to install new updates. You can also choose to install updates during automatic maintenance, on a particular day and time, and you can even check the option to include other Microsoft product updates when updating the OS.

Tuesday, July 25, 2017

The End of an Era – Next Steps for Adobe Flash

Today, Adobe announced that Flash will no longer be supported after 2020. Microsoft will phase out support for Flash in Microsoft Edge and Internet Explorer ahead of this date.

Flash led the way on the web for rich content, gaming, animations, and media of all kinds, and inspired many of the current web standards powering HTML5. Adobe has partnered with Microsoft, Google, Mozilla, Apple, and many others, to ensure that the open web could meet and exceed the experiences that Flash has traditionally provided. HTML5 standards, implemented across all modern browsers, provide these capabilities with improved performance, battery life, and increased security. We look forward to continuing to work with Adobe and our industry partners on enriching the open web without the need for plug-ins.

We will phase out Flash from Microsoft Edge and Internet Explorer, culminating in the removal of Flash from Windows entirely by the end of 2020. This process began already for Microsoft Edge with Click-to-Run for Flash in the Windows 10 Creators Update. The process will continue in the following phases:

Through the end of 2017 and into 2018, Microsoft Edge will continue to ask users for permission to run Flash on most sites the first time the site is visited, and will remember the user’s preference on subsequent visits. Internet Explorer will continue to allow Flash with no special permissions required during this time.
In mid to late 2018, we will update Microsoft Edge to require permission for Flash to be run each session. Internet Explorer will continue to allow Flash for all sites in 2018.
In mid to late 2019, we will disable Flash by default in both Microsoft Edge and Internet Explorer. Users will be able to re-enable Flash in both browsers. When re-enabled, Microsoft Edge will continue to require approval for Flash on a site-by-site basis.
By the end of 2020, we will remove the ability to run Adobe Flash in Microsoft Edge and Internet Explorer across all supported versions of Microsoft Windows. Users will no longer have any ability to enable or run Flash.
This timeline is consistent across browsers, including Google, Mozilla, and Apple. We look forward to continuing our close collaboration with Adobe, other browser vendors, and the publishing community, as we evolve the future of the web for everyone.
windows helpline number
windows helpline

Monday, July 24, 2017

New Lights and PropertySet Interop – XAML and Visual Layer Interop, Part Two

In the last post, we explored using XamlCompositionBrushBase and LoadedImageSurface to create custom CompositionBrushes that can be used to paint XAML elements directly in your markup. In today’s post, we’ll continue our look into the new improvements made to the XAML and Visual Layer Interop APIs available in the Windows 10 Creators Update.
In this blog series, we’ll cover some of these improvements in the Creators Update and look at the following APIs:

In Part 1:
XamlCompositionBrushBase – easily paint a XAML UIElement with a CompositionBrush
LoadedImageSurface – load an image easily and use with Composition APIs
In Part 2, today’s post:
XamlLights – apply lights to your XAML UI with a single line of XAML
PointerPositionPropertySet – create 60 FPS animations using pointer position, off the UI thread!
Enabling the Translation property – animate a XAML UI Element using Composition animation
If you’d like to review the previously available ElementCompositionPreview APIs, for example working with “hand-in” and “hand-out” Visuals, you can quickly catch up here.

Lighting UI with XamlLights

A powerful new feature in the Creators Update is the ability to set and use a Lighting effect directly in XAML by leveraging the abstract XamlLight class.

Creating a XamlLight starts just like a XamlCompositionBrushBase does, with an OnConnected and OnDisconnected method (see Part One here), but this time you inherit from the XamlLight subclass to create your own unique lighting that can be used directly in XAML. Microsoft uses this with the Reveal effect that comes with the Creators Update.

To see this in action, let’s build a demo that creates the animated GIF you see at the top of this post. It combines everything you learned about XamlCompositionBrushBase and LoadedImageSurface in the last post, but this example has two XamlLights: a HoverLight and an AmbientLight.

Let’s begin with creating the AmbientLight first. To get started, we begin similarly to the XamlCompositionBrushBase with an OnConnected and OnDisconnected method. However, for a XamlLight we set the CompositionLight property of the XamlLight subclass.

public class AmbLight : XamlLight
{
    protected override void OnConnected(UIElement newElement)
    {
        Compositor compositor = Window.Current.Compositor;

        // Create AmbientLight and set its properties
        AmbientLight ambientLight = compositor.CreateAmbientLight();
        ambientLight.Color = Colors.White;

        // Associate CompositionLight with XamlLight
        CompositionLight = ambientLight;

        // Add UIElement to the Light's Targets
        AmbLight.AddTargetElement(GetId(), newElement);
    }

    protected override void OnDisconnected(UIElement oldElement)
    {
        // Dispose Light when it is removed from the tree
        AmbLight.RemoveTargetElement(GetId(), oldElement);
        CompositionLight.Dispose();
    }

    protected override string GetId() => typeof(AmbLight).FullName;
}
With ambient lighting done, let’s build the SpotLight XamlLight. One of the main things we want the SpotLight to do is follow the user’s pointer. To do this, we can now use GetPointerPositionPropertySet method of ElementCompositionPreview to get a CompositionPropertySet we can use with a Composition ExpressionAnimation (PointerPositionPropertySet is explained in more detail in the PropertySets section below).

Here is the finished XamlLight implementation that creates that animated spotlight. Read the code comments to see the main parts of the effects, particularly how the resting position and animated offset position are used to create the lighting.
public class HoverLight : XamlLight
{
    private ExpressionAnimation _lightPositionExpression;
    private Vector3KeyFrameAnimation _offsetAnimation;

    protected override void OnConnected(UIElement targetElement)
    {
        Compositor compositor = Window.Current.Compositor;

        // Create SpotLight and set its properties
        SpotLight spotLight = compositor.CreateSpotLight();
        spotLight.InnerConeAngleInDegrees = 50f;
        spotLight.InnerConeColor = Colors.FloralWhite;
        spotLight.OuterConeAngleInDegrees = 0f;
        spotLight.ConstantAttenuation = 1f;
        spotLight.LinearAttenuation = 0.253f;
        spotLight.QuadraticAttenuation = 0.58f;

        // Associate CompositionLight with XamlLight
        this.CompositionLight = spotLight;

        // Define resting position Animation
        Vector3 restingPosition = new Vector3(200, 200, 400);
        CubicBezierEasingFunction cbEasing = compositor.CreateCubicBezierEasingFunction( new Vector2(0.3f, 0.7f), new Vector2(0.9f, 0.5f));
        _offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
        _offsetAnimation.InsertKeyFrame(1, restingPosition, cbEasing);
        _offsetAnimation.Duration = TimeSpan.FromSeconds(0.5f);

        spotLight.Offset = restingPosition;

        // Define expression animation that relates light's offset to pointer position
        CompositionPropertySet hoverPosition = ElementCompositionPreview.GetPointerPositionPropertySet(targetElement);
        _lightPositionExpression = compositor.CreateExpressionAnimation("Vector3(hover.Position.X, hover.Position.Y, height)");
        _lightPositionExpression.SetReferenceParameter("hover", hoverPosition);
        _lightPositionExpression.SetScalarParameter("height", 15.0f);

        // Configure pointer entered/ exited events
        targetElement.PointerMoved += TargetElement_PointerMoved;
        targetElement.PointerExited += TargetElement_PointerExited;

        // Add UIElement to the Light's Targets
        HoverLight.AddTargetElement(GetId(), targetElement);
    }

    private void MoveToRestingPosition()
    {
        // Start animation on SpotLight's Offset
        CompositionLight?.StartAnimation("Offset", _offsetAnimation);
    }

    private void TargetElement_PointerMoved(object sender, PointerRoutedEventArgs e)
    {
        if (CompositionLight == null) return;

        // touch input is still UI thread-bound as of the Creators Update
        if (e.Pointer.PointerDeviceType == Windows.Devices.Input.PointerDeviceType.Touch)
        {
            Vector2 offset = e.GetCurrentPoint((UIElement)sender).Position.ToVector2();
            (CompositionLight as SpotLight).Offset = new Vector3(offset.X, offset.Y, 15);
        }
        else
        {
            // Get the pointer's current position from the property and bind the SpotLight's X-Y Offset
            CompositionLight.StartAnimation("Offset", _lightPositionExpression);
        }
    }

    private void TargetElement_PointerExited(object sender, PointerRoutedEventArgs e)
    {
        // Move to resting state when pointer leaves targeted UIElement
        MoveToRestingPosition();
    }

    protected override void OnDisconnected(UIElement oldElement)
    {
        // Dispose Light and Composition resources when it is removed from the tree
        HoverLight.RemoveTargetElement(GetId(), oldElement);
        CompositionLight.Dispose();
        _lightPositionExpression.Dispose();
        _offsetAnimation.Dispose();
    }

    protected override string GetId() => typeof(HoverLight).FullName;
}
Now, with the HoverLight class done, we can add both the AmbLight and the HoverLight to previous ImageEffectBrush (find ImageEffectBrush in the last post):

<Grid>
            <Grid.Background>
                <brushes:ImageEffectBrush ImageUriString="ms-appx:///Images/Background.png" />
            </Grid.Background>
 
            <Grid.Lights>
                <lights:HoverLight/>
                <lights:AmbLight/>
            </Grid.Lights>
</Grid>
Note: To add a XamlLight in markup, your Min SDK version must be set to Creators Update, otherwise you can set it in the code behind.

For more information, go here to read more about using XamlLight and here to see the Lighting documentation.

Using CompositionPropertySets

When you want to use the values of the ScrollViewer’s Offset or the Pointer’s X and Y position (e.g. mouse cursor) to do things like animate effects, you can use ElementCompositionPreview to retrieve their PropertySets. This allows you to create amazingly smooth, 60 FPS animations that are not tied to the UI thread. These methods let you get the values from user interaction for things like animations and lighting.

Using ScrollViewerManipulationPropertySet

This PropertySet is useful for animating things like Parallax, Translation and Opacity.

// Gets the manipulation <ScrollViewer x:Name="MyScrollViewer"/>
CompositionPropertySet scrollViewerManipulationPropertySet =
    ElementCompositionPreview.GetScrollViewerManipulationPropertySet(MyScrollViewer);
To see an example, go to the Smooth Interaction and Motion blog post in this series. There is a section devoted to using the ScrollViewerManipulationPropertySet to drive the animation.

Using PointerPositionPropertySet (new!)

New in the Creators Update, is the PointerPositionPropertySet. This PropertySet is useful for creating animations for lighting and tilt. Like ScrollViewerManipulationPropertySet, PointerPositionPropertySet enables fast, smooth and UI thread independent animations.

A great example of this is the animation mechanism behind Fluent Design’s RevealBrush, where you see lighting effects on the edges on the UIElements. This effect is created by a CompositionLight, which has an Offset property animated by an ExpressionAnimation using the values obtained from the PointerPositionPropertySet.

// Useful for creating an ExpressionAnimation
CompositionPropertySet pointerPositionPropertySet = ElementCompositionPreview.GetPointerPositionPropertySet(targetElement);
ExpressionAnimation expressionAnimation = compositor.CreateExpressionAnimation("Vector3(param.Position.X, param.Position.Y, height)");
expressionAnimation.SetReferenceParameter("param", pointerPositionPropertySet);
To get a better understanding of how you can use this to power animations in your app, let’s explore XamlLights and create a demo that uses the PointerPositionPropertySet to animate a SpotLight.

Enabling Translation Property – Animating a XAML Element’s Offset using Composition Animations

As discussed in our previous blog post, property sharing between the Framework Layer and the Visual Layer used to be tricky prior to the Creators Update. The following Visual properties are shared between UIElements and their backing Visuals:

Offset
Scale
Opacity
TransformMatrix
InsetClip
CompositeMode
Prior to the Creators update, Scale and Offset were especially tricky because, as mentioned before, a UIElement isn’t aware of changes to the property values on the hand-out Visual, even though the hand-out Visual is aware of changes to the UIElement. Consequently, if you change the value of the hand-out Visual’s Offset or Size property and the UIElement’s position changes due to a page resize, the UIElement’s previous position values will stomp all over your hand-out Visual’s values.

Now with the Creators Update, this has become much easier to deal with as you can prevent Scale and Offset stomping by enabling the new Translation property on your element, by way of the ElementCompositionPreview object.


ElementCompositionPreview.SetIsTranslationEnabled(Rectangle1, true);

//Now initialize the value of Translation in the PropertySet to zero for first use to avoid timing issues. This ensures that the property is ready for use immediately.

var rect1VisualPropertySet = ElementCompositionPreview.GetElementVisual(Rectangle1).Properties;
rect1VisualPropertySet.InsertVector3("Translation", Vector3.Zero);
Then, animate the visual’s Translation property where previously you would have animated its Offset property.

// Old way, subject to property stomping:
visual.StartAnimation("Offset.Y", animation);
// New way, available in the Creators Update
visual.StartAnimation("Translation.Y", animation);
By animating a different property from the one affected during layout passes, you avoid any unwanted offset stomping coming from the XAML layer.

Wrapping up

In the past couple posts, we explored some of the new features of XAML and Composition Interop and how using Composition features in your XAML markup is easier than ever. From painting your UIElements with CompositionBrushes and applying lighting, to smooth off-UIThread animations, the power of the Composition API is more accessible than ever.

In the next post, we’ll dive deeper into how you can chain Composition effects to create amazing materials and help drive the evolution of Fluent Design.

Resources

XAML Composition Interop Behavior Changes
Visual Layer with XAML
XamlCompositionBrushBase
XamlLight
Lighting Overview (Documentation)
LoadedImageSurface

Windows Helpline Number
Windows Helpline

Windows Template Studio 1.2 released!

We’re extremely excited to announce the Windows Template Studio 1.2. What makes this release even more special is we’ve been accepted into the .NET Foundation! We are thrilled to be accepted in.
In this release, our major new feature is adding content into an existing application with Right-click add. We’ve grown up past only File->New 🙂
What’s new:
Full list of adjustments in the 1.2 release, head over to WTS’s Github.
Improvements to the Wizard:
Add new content to existing WTS generated projects in your solution window via right-click
We will be working toward seeing how we can enable this for non-WTS generated projects
Adjusted ordering of templates based on popularity and logical groupings
Under the hood, we’ve done a lot of work toward localization and started some accessibility improvements
Simplified descriptions
Logo adjustment to help at smaller icon sizes
Feature updates:
First-time load prompt
What’s New prompt
Template improvements:
Upgraded references to UWP Community Toolkit 1.5
Styling adjustments
Template generation post-action improvements
Process improvements:
Added in pull request template
Added in Issue template
How to get the update:

There are two paths to update to the newest build:
Already installed: Visual Studio should auto update the extension. To force an update, Go to Tools->Extensions and Updates. Then go to Update expander on the left and you should see Windows Template Studio in there and click “Update”
Not installed: Head to https://aka.ms/wtsinstall, click “download” and double click the VSIX installer.
What else is cooking for next versions?
We love all the community support and participation. In addition, here are just a few of the things we are currently building out that will in future builds:
Fluent design in the templates
Project Rome features as options for your project
Ink templates
Improved Right-click->add support for existing projects
Localization in the wizard
Full accessibility supported in both wizard and in the templates
Visual Basic support
With partnership with the community, we’ve will continue cranking out and iterating new features and functionality.  We’re always looking for additional people to help out and if you’re interested, please head to our GitHub at https://aka.ms/wts. If you have an idea or feature request, please make the request!
.NET Foundation:
We are happy to say that we’ve been accepted into the .NET Foundation. Such great open source projects like .NET Core, Roslyn and UWP Community Toolkit are just a few of the projects there, and now Windows Template Studio will be there as well!
windows helpline number
windows helpline