【人人都可以當整理師,將你的英文理出脈絡】
不管是因為 Netflix 影集紅遍全球的 Marie Kondo 整理術(中文譯:怦然心跳的整理魔法)還是韓劇 Move to Heaven(中文譯:遺物整理師),對於東西「有感覺」、並理出頭緒加以「分析」、「整理」,都是兩位主角共同的特質。
如果將這套理論用在英語學習上 input 的處理 ,其實大多的時候我們聽到、讀到英文時都「沒有什麼感覺」,更難以去分析、整理了。
在這樣的前提下,英文口說、寫作要有顯著的進步,更加不可能了(我們 #根本不記得我們聽了什麼讀了什麼)。
基於過去超過 25 年的語言學習歷程以及超過 50 年的第二語言習得科學研究,我研發出了已經超過 3335 位同學共同參與的 3D 英文筆記術,就是想要分享給大家像是 Marie Kondo 一樣,對於語言的 input 整理的能力。
✔︎ 在 Netflix 看 The Bold Type 這個美劇時,我整理到了 You shouldn’t throw your hat in the ring 這個 1 號公式(#片語)。
✔︎ 也整理到了 Let's pick up this conversation again. 這個 2 號公式(#片語動詞、#搭配詞)。
✔︎ 在聽 No Stupid Questions 時,我整理到了在發表意見時的發語詞 I’ll say this.(#情境式語塊)。
用 #Notion 當工具(課程中會教怎麼用)、以 #8大公式 為系統,你也可以像整理師一樣,看到東西、聽到東西時有感覺、能 #找出脈絡。有脈絡,才 #不會每次要用英文時腦中一片空白。
課程限時優惠最後倒數了囉,don’t miss the boat! 😊
🔥 《3D 英文筆記術》課程連結 :
https://hahow.in/cr/ntealex-3dnotetaking
🔥 領取好學校 #單堂課程88折兩堂以上83折折扣券:
https://bit.ly/3cDdsGj
Photo credit: Netflix
「your input中文」的推薦目錄:
- 關於your input中文 在 Alexander Wang 王梓沅英文 Facebook 的最佳解答
- 關於your input中文 在 SJE 。 閱讀紀錄 Facebook 的最佳解答
- 關於your input中文 在 李焯寧 Karen Lee Cheuk Ling Facebook 的最讚貼文
- 關於your input中文 在 How to input Chinese with your mouse 如何使用滑鼠輸入中文 的評價
- 關於your input中文 在 Digital Chinese Input Method. 數碼中文輸入法 - Facebook 的評價
- 關於your input中文 在 OAuth 2.0 for TV and Limited-Input Device Applications 的評價
your input中文 在 SJE 。 閱讀紀錄 Facebook 的最佳解答
🌱#LitPro紀錄 ▶ Julia 📎《2019暑假》
.
暑假兩個月咻一下就過完,如果沒有這些紀錄也無法想像『原來還是完成了很多事』...
.
暑期每天固定需要練琴、練球和日課,閱讀時間分配上仍與先前上學期間一樣。
.
為考量也得給孩子們(SJ)身心靈放鬆,在安排上就會多"聽"代替"閱讀"來掌握閱讀進度(input),Julia在:
#聽的方面:以『The Zack files』這套聽後測LitPro測驗。
#讀的方面:以『Let's read and find out scinece』、『Owl Diaries』這套讀後測LitPro測驗(有些無法測)。
#中文部分:還想賴床時讀中繪、讀月刊(TOP945進階版)
#科普的重心除了科英繪也做了很多IXL(改日再詳細紀錄)
#Neflix或YouTube影片也看了一堆
.
暑假的尾聲聽了兩本小說『Harry Potter 6』和『How to train your dragon』,但Julia無法掌握細節而LitPro/AR測驗沒通過,她也很堅持她有測驗就好不要破壞她的閱讀胃口...
於是考量基本功,讓Julia繼續從橋梁書『Secrets of Droon Series』打底起,有空的時後就隨她喜歡保持聽『Harry Potter 7』,享受閱讀和聽故事的樂趣~
(LitPro紀錄待貼留言串)
.
✏#2019_J_三年級
your input中文 在 李焯寧 Karen Lee Cheuk Ling Facebook 的最讚貼文
有時間既時候我會睇下書,
大部份都係英文書,
鍾意睇Philosophy, Leadership & Economics,
因爲感覺睇英文快d,
可以一目幾行😂
而中文書就故事性具多,
我最近就睇緊本How to live like your cat,
哲學放鬆性質。
你哋呢?鍾意睇咩書呀?
.
.
.
#library #reading #books #ilovereading #relaxmymind #relaxing #input #修練 #學習 #keeplearning
your input中文 在 Digital Chinese Input Method. 數碼中文輸入法 - Facebook 的美食出口停車場
Introduction of Digital Chinese Input Method. 數碼 中文 輸入法簡介#數碼 中文 輸入法# 中文 輸入法#輸入法. ... <看更多>
your input中文 在 OAuth 2.0 for TV and Limited-Input Device Applications 的美食出口停車場
Important note: This OAuth 2.0 flow supports a
limited set of scopes.
This document explains how to implement OAuth 2.0 authorization to access
the YouTube Data API via applications running on devices like TVs, game consoles, and
printers. More specifically, this flow is designed for devices that either do not have access
to a browser or have limited input capabilities.
OAuth 2.0 allows users to share specific data with an application while keeping their
usernames, passwords, and other information private.
For example, a TV application could use OAuth 2.0 to obtain permission to
select a file stored on Google Drive.
Since the applications that use this flow are distributed to individual devices, it is
assumed that the apps cannot keep secrets. They can access Google APIs while the user is
present at the app or when the app is running in the background.
Alternatives
If you are writing an app for a platform like Android, iOS, macOS, Linux, or Windows
(including the Universal Windows Platform), that has access to the browser and full input
capabilities, use the OAuth 2.0 flow for mobile
and desktop applications. (You should use that flow even if your app is a command-line
tool without a graphical interface.)
If you only want to sign in users with their Google accounts and use
JWT ID token to obtain basic user profile information,
see Sign-In
on TVs and Limited Input Devices.
Prerequisites
Enable APIs for your project
Any application that calls Google APIs needs to enable those APIs in the
API Console.
To enable an API for your project:
Open the API Library in the
Google API Console.
If prompted, select a project, or create a new one. Use the Library page to find and enable the YouTube Data API. Find any other
APIs that your application will use and enable those, too.
Create authorization credentials
Any application that uses OAuth 2.0 to access Google APIs must have authorization credentials
that identify the application to Google's OAuth 2.0 server. The following steps explain how to
create credentials for your project. Your applications can then use the credentials to access APIs
that you have enabled for that project.
Go to the Clients page.
Click Create Client.
Select the TVs and Limited Input devices application type.
Name your OAuth 2.0 client and click Create.
Identify access scopes
Scopes enable your application to only request access to the resources that it needs while also
enabling users to control the amount of access that they grant to your application. Thus, there
may be an inverse relationship between the number of scopes requested and the likelihood of
obtaining user consent.
Before you start implementing OAuth 2.0 authorization, we recommend that you identify the scopes
that your app will need permission to access.
Note: Incremental authorization is not supported for installed apps or
devices.
The YouTube Data API v3 uses the following scopes:
Scopes
https://www.googleapis.com/auth/youtubeManage your YouTube account
https://www.googleapis.com/auth/youtube.channel-memberships.creatorSee a list of your current active channel members, their current level, and when they became a member
https://www.googleapis.com/auth/youtube.force-sslSee, edit, and permanently delete your YouTube videos, ratings, comments and captions
https://www.googleapis.com/auth/youtube.readonlyView your YouTube account
https://www.googleapis.com/auth/youtube.uploadManage your YouTube videos
https://www.googleapis.com/auth/youtubepartnerView and manage your assets and associated content on YouTube
https://www.googleapis.com/auth/youtubepartner-channel-auditView private information of your YouTube channel relevant during the audit process with a YouTube partner
See the Allowed scopes list for installed apps or devices.
If your public application uses scopes that permit access to
certain user data, it must complete a verification process. If you see unverified
app on the screen when testing your application, you must submit a
verification request to remove it. Find out more about
unverified apps
and get answers to
frequently asked questions about app verification in the Help Center.
Obtaining OAuth 2.0 access tokens
Even though your application runs on a device with limited input capabilities, users must have
separate access to a device with richer input capabilities to complete this authorization flow.
The flow has the following steps:
Your application sends a request to Google's authorization server that identifies the scopes
that your application will request permission to access.
The server responds with several pieces of information used in subsequent steps, such as a
device code and a user code.
You display information that the user can enter on a separate device to authorize your
app.
Your application starts polling Google's authorization server to determine whether the user
has authorized your app.
The user switches to a device with richer input capabilities, launches a web browser,
navigates to the URL displayed in step 3 and enters a code that is also displayed in step 3. The
user can then grant (or deny) access to your application.
The next response to your polling request contains the tokens your app needs to authorize
requests on the user's behalf. (If the user refused access to your application, the response
does not contain tokens.)
The image below illustrates this process:

The following sections explain these steps in detail. Given the range of capabilities and runtime
environments that devices may have, the examples shown in this document use the curl
command line utility. These examples should be easy to port to various languages and runtimes.
In this step, your device sends an HTTP POST request to Google's authorization server, at
https://oauth2.googleapis.com/device/code
, that identifies your application
as well as the access scopes that your application wants to access on the user's behalf.
You should retrieve this URL from the
Discovery document using the
device_authorization_endpoint
metadata value. Include the following HTTP request
parameters:
Parameters
client_id
Required
The client ID for your application. You can find this value in the
Cloud Console
Clients page.
scope
Required
A
space-delimited
list of scopes that identify the resources that your application could access on the
user's behalf. These values inform the consent screen that Google displays to the
user. See the
Allowed scopes list for installed apps or devices.
Scopes enable your application to only request access to the resources that it needs
while also enabling users to control the amount of access that they grant to your
application. Thus, there is an inverse relationship between the number of scopes requested
and the likelihood of obtaining user consent.
The YouTube Data API v3 uses the following scopes:
Scopes
https://www.googleapis.com/auth/youtubeManage your YouTube account
https://www.googleapis.com/auth/youtube.channel-memberships.creatorSee a list of your current active channel members, their current level, and when they became a member
https://www.googleapis.com/auth/youtube.force-sslSee, edit, and permanently delete your YouTube videos, ratings, comments and captions
https://www.googleapis.com/auth/youtube.readonlyView your YouTube account
https://www.googleapis.com/auth/youtube.uploadManage your YouTube videos
https://www.googleapis.com/auth/youtubepartnerView and manage your assets and associated content on YouTube
https://www.googleapis.com/auth/youtubepartner-channel-auditView private information of your YouTube channel relevant during the audit process with a YouTube partner
The OAuth 2.0 API Scopes document provides
a full list of scopes that you might use to access Google APIs.
Examples
The following snippet shows a sample request:
POST /device/code HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencodedclient_id=client_id&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly
This example shows a curl
command to send the same request:
Step 2: Handle the authorization server response
curl -d "client_id=client_id&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly" \
https://oauth2.googleapis.com/device/code
The authorization server will return one of the following responses:
Success responseIf the request is valid, your response will be a JSON object containing the following
properties:
Properties
device_code
A value that Google uniquely assigns to identify the device that runs the app requesting
authorization. The user will be authorizing that device from another device with richer
input capabilities. For example, a user might use a laptop or mobile phone to authorize an
app running on a TV. In this case, the
device_code
identifies the TV. This code lets the device running the app securely determine whether the user has granted
or denied access.
expires_in
The length of time, in seconds, that the
device_code
anduser_code
are valid. If, in that time, the user doesn't complete theauthorization flow and your device doesn't also poll to retrieve information about the
user's decision, you might need to restart this process from step 1.
interval
The length of time, in seconds, that your device should wait between polling requests. For
example, if the value is
5
, your device should send a polling request toGoogle's authorization server every five seconds. See
step 3 for more details.
user_code
A case-sensitive value that identifies to Google the scopes that the application is
requesting access to. Your user interface will instruct the user to enter this value on a
separate device with richer input capabilities. Google then uses the value to display the
correct set of scopes when prompting the user to grant access to your application.
verification_url
A URL that the user must navigate to, on a separate device, to enter the
user_code
and grant or deny access to your application. Your user interfacewill also display this value.
The following snippet shows a sample response:
{
"device_code": "4/4-GMMhmHCXhWEzkobqIHGG_EnNYYsAkukHspeYUk9E8",
"user_code": "GQVQ-JKEC",
"verification_url": "https://www.google.com/device",
"expires_in": 1800,
"interval": 5
}
Quota exceeded response
If your device code requests have exceeded the quota associated with your client ID, you will
receive a 403 response, containing the following error:
{
"error_code": "rate_limit_exceeded"
}
In that case, use a backoff strategy to reduce the rate of requests.
Step 3: Display the user code
Display the verification_url
and user_code
obtained in step 2 to the
user. Both values can contain any printable character from the US-ASCII character set. The content
that you display to the user should instruct the user to navigate to the
verification_url
on a separate device and enter the user_code
.
Design your user interface (UI) with the following rules in mind:
user_code
The
user_code
must be displayed in a field that can handle 15 'W' sizecharacters. In other words, if you can display the code
WWWWWWWWWWWWWWW
correctly, your UI is valid, and we recommend using that string value when testing the way
the
user_code
displays in your UI.The
user_code
is case-sensitive and should not be modified in any way, suchas changing the case or inserting other formatting characters.
verification_url
The space where you display the
verification_url
must be wide enough tohandle a URL string that is 40 characters long.
You should not modify the
verification_url
in any way, except to optionallyremove the scheme for display. If you do plan to strip off the scheme
(e.g.
https://
) from the URL for display reasons, be sure your app can handleboth
http
and https
variants.Warning: Both of these values are subject to change, and you should
not hardcode either value in your code. Similarly, you should not modify the values in any way
other than optionally removing the scheme from the
verification_url
.Step 4: Poll Google's authorization serverSince the user will be using a separate device to navigate to the verification_url
and grant (or deny) access, the requesting device is not automatically notified when the user
responds to the access request. For that reason, the requesting device needs to poll Google's
authorization server to determine when the user has responded to the request.
The requesting device should continue sending polling requests until it receives a response
indicating that the user has responded to the access request or until the device_code
and user_code
obtained in
step 2 have expired. The interval
returned in step 2 specifies the amount of
time, in seconds, to wait between requests.
The URL of the endpoint to poll is https://oauth2.googleapis.com/token
. The polling request
contains the following parameters:
Parameters
client_id
The client ID for your application. You can find this value in the
Cloud Console
Clients page.
client_secret
The client secret for the provided
client_id
. You can find this value in theCloud Console
Clients page.
device_code
The
device_code
returned by the authorization server instep 2.
grant_type
Set this value to
urn:ietf:params:oauth:grant-type:device_code
.Examples
The following snippet shows a sample request:
POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencodedclient_id=client_id&
client_secret=client_secret&
device_code=device_code&
grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code
This example shows a curl
command to send the same request:
Step 5: User responds to access requestNote: Your application does not need to do anything at this stage aside
curl -d "client_id=client_id&client_secret=client_secret& \
device_code=device_code& \
grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code" \
-H "Content-Type: application/x-www-form-urlencoded" \
https://oauth2.googleapis.com/token
from polling the authorization server as described in the previous step.
The following image shows a page similar to what users see when they navigate to the
verification_url
that you displayed in step 3:

After entering the user_code
and, if not already logged-in, logging in to Google,
the user sees a consent screen like the one shown below:

Google's authorization server responds to each polling request with one of the following
responses:
If the user granted access to the device (by clicking Allow
on the consent screen),
then the response contains an access token and a refresh token. The tokens enable your device to
access Google APIs on the user's behalf. (The scope
property in the response determines which APIs the
device can access.)
In this case, the API response contains the following fields:
Fields
access_token
The token that your application sends to authorize a Google API request.
expires_in
The remaining lifetime of the access token in seconds.
refresh_token
A token that you can use to obtain a new access token. Refresh tokens are valid until the
user revokes access or the refresh token expires.
Note that refresh tokens are always returned for devices.
refresh_token_expires_in
The remaining lifetime of the refresh token in seconds. This value is only set when the
user grants time-based
access.
scope
The scopes of access granted by the
access_token
expressed as a list ofspace-delimited, case-sensitive strings.
token_type
The type of token returned. At this time, this field's value is always set to
Bearer
.The following snippet shows a sample response:
{
"access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
"expires_in": 3920,
"scope": "openid https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email",
"token_type": "Bearer",
"refresh_token": "1/xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
}
Access tokens have a limited lifetime. If your application needs access to an API over a long
period of time, it can use the refresh token to obtain a new access
token. If your application needs this type of access, then it should store the refresh token for
later use.
If the user refuses to grant access to the device, then the server response has a
403
HTTP response status code (Forbidden
). The response contains the
following error:
{Authorization pending
"error": "access_denied",
"error_description": "Forbidden"
}
If the user has not yet completed the authorization flow, then the server returns a
428
HTTP response status code (Precondition Required
). The response
contains the following error:
{Polling too frequently
"error": "authorization_pending",
"error_description": "Precondition Required"
}
If the device sends polling requests too frequently, then the server returns a 403
HTTP response status code (Forbidden
). The response contains the following
error:
{Other errors
"error": "slow_down",
"error_description": "Forbidden"
}
The authorization server also returns errors if the polling request is missing any required
parameters or has an incorrect parameter value. These requests usually have a 400
(Bad Request
) or 401
(Unauthorized
) HTTP response status
code. Those errors include:
Error
HTTP Status Code
Description
admin_policy_enforced
400
The Google Account is unable to authorize one or more scopes requested due to the
policies of their Google Workspace administrator. See the Google Workspace Admin help
article Control which third-party &
internal apps access Google Workspace data for more information about how an
administrator may restrict access to scopes until access is explicitly granted to your OAuth
client ID.
invalid_client
401
The OAuth client was not found. For example, this error occurs if the
client_id
parameter value is invalid.
The OAuth client type is incorrect. Ensure that the
application type
for the client id is set to TVs and Limited Input devices.
invalid_grant
400
The
code
parameter value is invalid, has already been claimed or cannot beparsed.
unsupported_grant_type
400
The
grant_type
parameter value is invalid.org_internal
403
The OAuth client ID in the request is part of a project limiting access to Google Accounts
in a specific
Google Cloud Organization. Confirm the
user type
configuration for your OAuth application.
Calling Google APIs
After your application obtains an access token, you can use the token to make calls to a Google
API on behalf of a given
user account if the scope(s) of access required by the API have been granted. To do this, include
the access token in a request to the API by including either an access_token
query
parameter or an Authorization
HTTP header Bearer
value. When possible,
the HTTP header is preferable, because query strings tend to be visible in server logs. In most
cases you can use a client library to set up your calls to Google APIs (for example, when
calling the YouTube Data API).
Note that the YouTube Data API supports service accounts only for YouTube
content owners that own and manage multiple YouTube channels, such as record
labels and movie studios.
You can try out all the Google APIs and view their scopes at the
OAuth 2.0 Playground.
A call to the
youtube.channels
endpoint (the YouTube Data API) using the Authorization: Bearer
HTTP
header might look like the following. Note that you need to specify your own access token:
GET /youtube/v3/channels?part=snippet&mine=true HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token
Here is a call to the same API for the authenticated user using the access_token
query string parameter:
GET https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true
curl
examplesYou can test these commands with the curl
command-line application. Here's an
example that uses the HTTP header option (preferred):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true
Or, alternatively, the query string parameter option:
curl https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true
Refreshing an access token
Access tokens periodically expire and become invalid credentials for a related API request. You
can refresh an access token without prompting the user for permission (including when the user is
not present) if you requested offline access to the scopes associated with the token.
To refresh an access token, your application sends an HTTPS POST
request to Google's authorization server (https://oauth2.googleapis.com/token
) that
includes the following parameters:
Fields
client_id
The client ID obtained from the API Console.
client_secret
The client secret obtained from the API Console.
grant_type
As
defined in the
OAuth 2.0 specification,
this field's value must be set to refresh_token
.
refresh_token
The refresh token returned from the authorization code exchange.
The following snippet shows a sample request:
POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencodedclient_id=your_client_id&
client_secret=your_client_secret&
refresh_token=refresh_token&
grant_type=refresh_token
As long as the user has not revoked the access granted to the application, the token server
returns a JSON object that contains a new access token. The following snippet shows a sample
response:
{
"access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
"expires_in": 3920,
"scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
"token_type": "Bearer"
}
Note that there are limits on the number of refresh tokens that will be issued; one limit per
client/user combination, and another per user across all clients. You should save refresh tokens
in long-term storage and continue to use them as long as they remain valid. If your application
requests too many refresh tokens, it may run into these limits, in which case older refresh tokens
will stop working.
Revoking a token
In some cases a user may wish to revoke access given to an application. A user can revoke access
by visiting
Account Settings. See the
Remove
site or app access section of the Third-party sites & apps with access to your account
support document for more information.
It is also possible for an application to programmatically revoke the access given to it.
Programmatic revocation is important in instances where a user unsubscribes, removes an
application, or the API resources required by an app have significantly changed. In other words,
part of the removal process can include an API request to ensure the permissions previously
granted to the application are removed.
To programmatically revoke a token, your application makes a request to
https://oauth2.googleapis.com/revoke
and includes the token as a parameter:
curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
https://oauth2.googleapis.com/revoke?token={token}
The token can be an access token or a refresh token. If the token is an access token and it has a
corresponding refresh token, the refresh token will also be revoked.
If the revocation is successfully processed, then the HTTP status code of the response is
200
. For error conditions, an HTTP status code 400
is returned along
with an error code.
Note: Following a successful revocation response, it might take some
time before the revocation has full effect.
Allowed scopes
The OAuth 2.0 flow for devices is supported only for the following scopes:
OpenID Connect,
Google Sign-In
email
openid
profile
Drive API
https://www.googleapis.com/auth/drive.appdata
https://www.googleapis.com/auth/drive.file
YouTube API
https://www.googleapis.com/auth/youtube
https://www.googleapis.com/auth/youtube.readonly
Time-based access
Time-based access allows a user to grant your app access to their data for a limited duration
to complete an action. Time-based access is available in select Google products during the consent
flow, giving users the option to grant access for a limited period of time. An example is the
Data Portability API which enables a
one-time transfer of data.
When a user grants your application time-based access, the refresh token will expire after the
specified duration. Note that refresh tokens may be invalidated earlier under specific
circumstances; see these cases for
details. The refresh_token_expires_in
field returned in the
authorization code
exchange response represents the time remaining until the refresh token expires in such cases.
Implementing Cross-Account Protection
An additional step you should take to protect your users' accounts is implementing Cross-Account
Protection by utilizing Google's Cross-Account Protection Service. This service lets you
subscribe to security event notifications which provide information to your application about
major changes to the user account. You can then use the information to take action depending on
how you decide to respond to events.
Some examples of the event types sent to your app by Google's Cross-Account Protection Service are:
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked
https://schemas.openid.net/secevent/oauth/event-type/token-revoked
https://schemas.openid.net/secevent/risc/event-type/account-disabled
See the
Protect user accounts with Cross-Account Protection page
for more information on how to implement Cross Account Protection and for the full list of available events.
... <看更多>
your input中文 在 How to input Chinese with your mouse 如何使用滑鼠輸入中文 的美食出口停車場
輸入 中文 字是文書處理過程中比較困難的,尤其是在英文視窗作業環境下,不懂 中文 輸入法可以用手寫板,但如果沒有手寫板又想輸入 中文 ,可以按照以下方法 ... ... <看更多>