public static AttributeMetadata CreateFloatingPoint(double? minValue = 0, double? maxValue = 1000000000, int? precision = 2, ImeMode? mode = ImeMode.Auto)
{
if (precision < DoubleAttributeMetadata.MinSupportedPrecision || precision > DoubleAttributeMetadata.MaxSupportedPrecision)
{
throw new ArgumentOutOfRangeException(nameof(precision), "Precision is out of Range!");
}
if (minValue < DoubleAttributeMetadata.MinSupportedValue)
{
throw new ArgumentOutOfRangeException(nameof(minValue), "MinValue is out of Range!");
}
if (maxValue > DoubleAttributeMetadata.MaxSupportedValue)
{
throw new ArgumentOutOfRangeException(nameof(maxValue), "MaxValue is out of Range!");
}
return new DoubleAttributeMetadata
{
ImeMode = mode,
MaxValue = maxValue,
MinValue = minValue,
Precision = precision
};
}
private void CheckIME()
{
if (this.ImeMode != this.lastIMEMode)
{
this.lastIMEMode = this.ImeMode;
this.IMELabel.Text = "[" + this.ImeMode.ToString() + "]";
}
}
/// <summary>
/// Sets the IME mode.
/// </summary>
/// <param name="control">The control.</param>
/// <param name="imeMode">The IME mode.</param>
public static void SetImeMode(this Control control, ImeMode imeMode)
{
if (control.InvokeRequired)
{
control.BeginInvoke(new MethodInvoker(() => control.SetImeMode(imeMode)));
}
else
{
control.ImeMode = imeMode;
control.Refresh();
}
}
private InputScopeNameValue GetInputScope(ImeMode ime)
{
if (ime == ImeMode.Hiragana)
{
return(InputScopeNameValue.Hiragana);
}
if (ime == ImeMode.KatakanaHalf)
{
return(InputScopeNameValue.KatakanaHalfWidth);
}
return(InputScopeNameValue.Default);
}
/// <summary>
/// Sets the IME mode.
/// </summary>
/// <param name="pictureBox">The picture box.</param>
/// <param name="value">The value.</param>
public static void SetImeMode(this PictureBox pictureBox, ImeMode value)
{
if (pictureBox.InvokeRequired)
{
pictureBox.BeginInvoke(new MethodInvoker(() => pictureBox.SetImeMode(value)));
}
else
{
pictureBox.ImeMode = value;
pictureBox.Refresh();
}
}
/// <summary>
/// Sets the IME mode.
/// </summary>
/// <param name="control">The control.</param>
/// <param name="value">The value.</param>
public static void SetImeMode(this ButtonBase control, ImeMode value)
{
if (control.InvokeRequired)
{
control.BeginInvoke(new MethodInvoker(() => control.SetImeMode(value)));
}
else
{
control.ImeMode = value;
control.Refresh();
}
}
public static AttributeMetadata CreateText(int? maxLength = null, StringFormatName formatName = null, ImeMode? imeMode = ImeMode.Auto, string yomiOf = null, string formulaDefinition = null)
{
maxLength = formulaDefinition != null && maxLength == null ? 4000 : 100;
return new StringAttributeMetadata
{
FormatName = formatName ?? StringFormatName.Text,
ImeMode = imeMode,
MaxLength = maxLength,
YomiOf = yomiOf,
FormulaDefinition = formulaDefinition
};
}
public void AxHost_ImeMode_Set_GetReturnsExpected(ImeMode value)
{
var control = new SubAxHost("00000000-0000-0000-0000-000000000000")
{
ImeMode = value
};
Assert.Equal(value, control.ImeMode);
// Set same.
control.ImeMode = value;
Assert.Equal(value, control.ImeMode);
}
public static ImeMode GetImeMode(IntPtr handle)
{
IntPtr zero = IntPtr.Zero;
ImeMode noControl = ImeMode.NoControl;
ImeMode[] inputLanguageTable = ImeModeConversion.InputLanguageTable;
if (inputLanguageTable == ImeModeConversion.UnsupportedTable)
{
noControl = ImeMode.Inherit;
}
else
{
zero = UnsafeNativeMethods.ImmGetContext(new HandleRef(null, handle));
if (zero == IntPtr.Zero)
{
noControl = ImeMode.Disable;
}
else if (!IsOpen(handle))
{
noControl = inputLanguageTable[3];
}
else
{
int conversion = 0;
int sentence = 0;
UnsafeNativeMethods.ImmGetConversionStatus(new HandleRef(null, zero), ref conversion, ref sentence);
if ((conversion & 1) != 0)
{
if ((conversion & 2) != 0)
{
noControl = ((conversion & 8) != 0) ? inputLanguageTable[6] : inputLanguageTable[7];
}
else
{
noControl = ((conversion & 8) != 0) ? inputLanguageTable[4] : inputLanguageTable[5];
}
}
else
{
noControl = ((conversion & 8) != 0) ? inputLanguageTable[8] : inputLanguageTable[9];
}
}
}
if (zero != IntPtr.Zero)
{
UnsafeNativeMethods.ImmReleaseContext(new HandleRef(null, handle), new HandleRef(null, zero));
}
return(noControl);
}
private void SetImeMode(Control ctrl, ImeMode mode)
{
IntPtr himc = ImmGetContext(ctrl.Handle);
Int32 dwConversion = 0;
try
{
switch (mode)
{
case ImeMode.DISABLE:
ImmAssociateContext(himc, 0);
break;
case ImeMode.OFF:
ImmAssociateContext(himc, 1);
ImmSetOpenStatus(himc, 0);
break;
case ImeMode.ON:
ImmAssociateContext(himc, 1);
ImmSetOpenStatus(himc, 1);
break;
case ImeMode.KOREAFULL:
dwConversion = NATIVE | FULLSHAPE | ROMAN;
ImmSetConversionStatus(himc, dwConversion, 0);
break;
case ImeMode.KOREA:
dwConversion = NATIVE | ROMAN;
ImmSetConversionStatus(himc, dwConversion, 0);
break;
case ImeMode.ALPHAFULL:
dwConversion = FULLSHAPE | ALPHANUMERIC;
ImmSetConversionStatus(himc, dwConversion, 0);
break;
case ImeMode.ALPHA:
dwConversion = ALPHANUMERIC;
ImmSetConversionStatus(himc, dwConversion, 0);
break;
}
}
finally
{
ImmReleaseContext(ctrl.Handle);
}
}
public static AttributeMetadata CreateText(int? maxLength = null, StringFormat? format = StringFormat.Text, StringFormatName formatName = null, ImeMode? imeMode = ImeMode.Auto, string yomiOf = null, string formulaDefinition = null)
{
maxLength = formulaDefinition != null && maxLength == null ? 4000 : 100;
if (formatName == null)
{
switch (format)
{
case StringFormat.Email:
formatName = StringFormatName.Email;
break;
case StringFormat.Text:
formatName = StringFormatName.Text;
break;
case StringFormat.TextArea:
formatName = StringFormatName.TextArea;
break;
case StringFormat.Url:
formatName = StringFormatName.Url;
break;
case StringFormat.TickerSymbol:
formatName = StringFormatName.TickerSymbol;
break;
case StringFormat.PhoneticGuide:
formatName = StringFormatName.PhoneticGuide;
break;
case StringFormat.VersionNumber:
formatName = StringFormatName.VersionNumber;
break;
case StringFormat.Phone:
formatName = StringFormatName.Url;
break;
case null:
break;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, "Unable to determine format Name for format: " + format);
}
}
return new StringAttributeMetadata
{
Format = format,
FormatName = formatName,
ImeMode = imeMode,
MaxLength = maxLength,
YomiOf = yomiOf,
FormulaDefinition = formulaDefinition
};
}
private CellStyle GetDefaultCellStyle(MultiRowContentAlignment align, ImeMode imeMode = ImeMode.Disable)
{
return(new CellStyle()
{
Border = border,
DisabledForeColor = Color.Black,
Font = Font,
ForeColor = Color.Black,
ImeMode = imeMode,
//InputScope = GetInputScope(imeMode),
ImeSentenceMode = ImeSentenceMode.Normal,
Padding = new Padding(2, -1, 2, -1),
TextEffect = TextEffect.Flat,
TextAlign = align,
WordWrap = MultiRowTriState.False
});
}
private void ChangeImeMode(string iso)
{
switch (iso)
{
case "ja":
offModeIME = ImeMode.Off;
break;
case "ko":
offModeIME = ImeMode.NoControl;
break;
case "zh":
offModeIME = ImeMode.NoControl;
break;
}
lastIMEMode = offModeIME;
}
public EntityAttributeMetadataBuilder DateTimeAttribute(string schemaName, string displayName, string description,
AttributeRequiredLevel requiredLevel,
DateTimeFormat format, ImeMode imeMode)
{
int languageCode = 1033;
// Create a date time attribute
var dtAttribute = new DateTimeAttributeMetadata
{
// Set base properties
SchemaName = schemaName,
DisplayName = new Label(displayName, languageCode),
RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
Description = new Label(description, languageCode),
// Set extended properties
Format = format,
ImeMode = imeMode
};
this.Attributes.Add(dtAttribute);
return this;
}
public EntityAttributeBuilder DateTimeAttribute(string schemaName, string displayName, string description,
AttributeRequiredLevel requiredLevel,
DateTimeFormat format, ImeMode imeMode)
{
int languageCode = 1033;
// Create a date time attribute
var dtAttribute = new DateTimeAttributeMetadata
{
// Set base properties
SchemaName = schemaName,
DisplayName = new Label(displayName, languageCode),
RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
Description = new Label(description, languageCode),
// Set extended properties
Format = format,
ImeMode = imeMode
};
this.Attributes.Add(dtAttribute);
return(this);
}
public GcTextBoxCell GetTextBoxCell(MultiRowContentAlignment align = MultiRowContentAlignment.MiddleLeft
, ImeMode ime = ImeMode.NoControl, string format = null, int?maxLength = null, bool isNumberCell = false
, GrapeCity.Win.Editors.LengthUnit maxLengthUnit = GrapeCity.Win.Editors.LengthUnit.Char)
{
var cell = !isNumberCell
? new GcTextBoxCell()
: new GcNumberTextBoxCell();
cell.AutoComplete.CandidateListItemFont = Font;
cell.AutoComplete.HighlightStyle.Font = Font;
cell.Format = format;
if (maxLength.HasValue)
{
cell.MaxLength = maxLength.Value;
}
cell.ExitOnArrowKey = true;
cell.ShortcutKeys.Remove(Keys.F2);
cell.ShortcutKeys.Remove(Keys.F4);
cell.Style = GetDefaultCellStyle(align, ime);
cell.MaxLengthUnit = maxLengthUnit;
return(cell);
}
public static DialogResult Show_Dialog(string msgText, string title, string defaultVal, out string result
, ImeMode imeMode, HorizontalAlignment align)
{
InputBox f = new InputBox(msgText, title, defaultVal);
f.textBox2.ImeMode = imeMode;
f.textBox2.TextAlign = align;
DialogResult dres = f.ShowDialog();
if (dres == DialogResult.OK)
{
result = f.textBox2.Text;
}
else
{
result = null;
}
f.Dispose();
return(dres);
}
public static AttributeMetadata CreateDateTime(DateTimeFormat? format = DateTimeFormat.DateOnly, ImeMode? mode = ImeMode.Auto, string formulaDefinition = null)
{
return new DateTimeAttributeMetadata
{
Format = format,
ImeMode = mode,
FormulaDefinition = formulaDefinition
};
}
public static void SetImeStatus(ImeMode imeMode, IntPtr handle)
{
throw null;
}
public DateTimeAttribute(Metadata.DateTimeFormat format, Metadata.ImeMode mode = Metadata.ImeMode.Disabled)
{
Format = format.ToSimilarEnum <DateTimeFormat>();
ImeMode = mode.ToSimilarEnum <ImeMode>();
}
/// <devdoc>
/// Handles the WM_KILLFOCUS message
/// </devdoc>
/// <internalonly/>
private void WmImeKillFocus() {
Debug.WriteLineIf(CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Inside WmImeKillFocus(), this=" + this);
Debug.Indent();
Control topMostWinformsParent = TopMostParent;
Form appForm = topMostWinformsParent as Form;
if( (appForm == null || appForm.Modal) && !topMostWinformsParent.ContainsFocus ) {
// This means the [....] component container is not a [....] host and it is no longer focused.
// Or it is not the main app host. See VSW#531520,604741 (VSU QFE#5055), DDB#95889, TFS VSTSDEVDIV463760
Debug.WriteLineIf(CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Unfocused TopMostParent = " + topMostWinformsParent);
// We need to reset the PropagatingImeMode to force reinitialization when the [....] component gets focused again;
// this enables inheritting the propagating mode from an unmanaged application hosting a [....] component.
// But before leaving the [....] container we need to set the IME to the propagating IME mode since the focused control
// may not support IME which would leave the IME disabled.
// See the PropagatingImeMode property and VSW#531520.
// Note: We need to check the static field here directly to avoid initialization of the property.
if (Control.propagatingImeMode != ImeMode.Inherit) {
// Setting the ime context of the top window will generate a WM_IME_NOTIFY on the focused control which will
// update its ImeMode, we need to prevent this temporarily.
IgnoreWmImeNotify = true;
try {
Debug.WriteLineIf(CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "Setting IME context to PropagatingImeMode (leaving [....] container). this = " + this);
ImeContext.SetImeStatus(PropagatingImeMode, topMostWinformsParent.Handle);
Debug.WriteLineIf(CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "Resetting PropagatingImeMode. this = " + this);
PropagatingImeMode = ImeMode.Inherit;
}
finally {
IgnoreWmImeNotify = false;
}
}
}
Debug.Unindent();
}
/// <devdoc>
/// Update internal ImeMode properties (PropagatingImeMode/CachedImeMode) with actual IME context mode if needed.
/// This method can be used with a child control when the IME mode is more relevant to it than to the control itself,
/// for instance ComboBox and its native ListBox/Edit controls.
/// </devdoc>
internal void OnImeContextStatusChanged( IntPtr handle ) {
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Inside OnImeContextStatusChanged(), this = " + this );
Debug.Indent();
Debug.Assert( ImeSupported, "WARNING: Attempting to update ImeMode properties on IME-Unaware control!" );
Debug.Assert( !DesignMode, "Shouldn't be updating cached ime mode at design-time" );
ImeMode fromContext = ImeContext.GetImeMode( handle );
if( fromContext != ImeMode.Inherit ) {
ImeMode oldImeMode = CachedImeMode;
if( CanEnableIme ) { // Cache or Propagating ImeMode should not be updated by interaction when the control is in restricted mode.
if( oldImeMode != ImeMode.NoControl ) {
CachedImeMode = fromContext; // This could end up in the same value due to ImeMode language mapping.
// ImeMode may be changing by user interaction.
VerifyImeModeChanged( oldImeMode, CachedImeMode );
}
else {
PropagatingImeMode = fromContext;
}
}
}
Debug.Unindent();
}
/// <devdoc>
/// Sets the IME context to the appropriate ImeMode according to the control's ImeMode state.
/// This method is commonly used when attaching the IME to the control's window.
/// </devdoc>
internal void UpdateImeContextMode() {
ImeMode[] inputLanguageTable = ImeModeConversion.InputLanguageTable;
if (!DesignMode && (inputLanguageTable != ImeModeConversion.UnsupportedTable) && Focused) {
// Note: CHN IME won't send WM_IME_NOTIFY msg when getting associated, setting the IME context mode
// forces the message to be sent as a side effect.
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Inside UpdateImeContextMode(), this = " + this );
Debug.Indent();
// If the value is not supported by the Ime, it will be mapped to a corresponding one, we need
// to update the cached ImeMode to the actual value.
ImeMode newImeContextMode = ImeMode.Disable;
ImeMode currentImeMode = CachedImeMode;
if( ImeSupported && CanEnableIme ) {
newImeContextMode = currentImeMode == ImeMode.NoControl ? PropagatingImeMode : currentImeMode;
}
// If PropagatingImeMode has not been initialized it will return ImeMode.Inherit above, need to check newImeContextMode for this.
if (CurrentImeContextMode != newImeContextMode && newImeContextMode != ImeMode.Inherit) {
// If the context changes the window will receive one or more WM_IME_NOTIFY messages and as part of its
// processing it will raise the ImeModeChanged event if needed. We need to prevent the event from been
// raised here from here.
DisableImeModeChangedCount++;
// Setting IME status to Disable will first close the IME and then disable it. For CHN IME, the first action will
// update the PropagatingImeMode to ImeMode.Close which is incorrect. We need to save the PropagatingImeMode in
// this case and restore it after the context has been changed. See VSW#530471
// Also this call here is very important since it will initialize the PropagatingImeMode if not already initialized
// before setting the IME context to the control's ImeMode value which could be different from the propagating value.
ImeMode savedPropagatingImeMode = PropagatingImeMode;
try {
ImeContext.SetImeStatus( newImeContextMode, this.Handle );
}
finally {
DisableImeModeChangedCount--;
if (newImeContextMode == ImeMode.Disable && inputLanguageTable == ImeModeConversion.ChineseTable) {
// Restore saved propagating mode.
PropagatingImeMode = savedPropagatingImeMode;
}
}
// Get mapped value from the context.
if( currentImeMode == ImeMode.NoControl ) {
if( CanEnableIme ) {
PropagatingImeMode = CurrentImeContextMode;
}
}
else {
if( CanEnableIme ) {
CachedImeMode = CurrentImeContextMode;
}
// Need to raise the ImeModeChanged event?
VerifyImeModeChanged( newImeContextMode, CachedImeMode );
}
}
ImeContext.TraceImeStatus( this );
Debug.Unindent();
}
}
public static void SetImeStatus(ImeMode imeMode, IntPtr handle)
{
if (imeMode == ImeMode.Inherit)
{
return;
}
if (imeMode == ImeMode.NoControl)
{
return;
}
ImeMode[] inputLanguageTable = ImeModeConversion.InputLanguageTable;
if (inputLanguageTable == ImeModeConversion.UnsupportedTable)
{
return;
}
int num = 0;
int sentence = 0;
if (imeMode == ImeMode.Disable)
{
Disable(handle);
}
else
{
Enable(handle);
}
switch (imeMode)
{
case ImeMode.NoControl:
case ImeMode.Disable:
return;
case ImeMode.On:
imeMode = ImeMode.Hiragana;
goto Label_0079;
case ImeMode.Off:
if (inputLanguageTable == ImeModeConversion.JapaneseTable)
{
break;
}
imeMode = ImeMode.Alpha;
goto Label_0079;
case ImeMode.Close:
break;
default:
goto Label_0079;
}
if (inputLanguageTable == ImeModeConversion.KoreanTable)
{
imeMode = ImeMode.Alpha;
}
else
{
SetOpenStatus(false, handle);
return;
}
Label_0079:
if (ImeModeConversion.ImeModeConversionBits.ContainsKey(imeMode))
{
ImeModeConversion conversion = ImeModeConversion.ImeModeConversionBits[imeMode];
IntPtr ptr = UnsafeNativeMethods.ImmGetContext(new HandleRef(null, handle));
UnsafeNativeMethods.ImmGetConversionStatus(new HandleRef(null, ptr), ref num, ref sentence);
num |= conversion.setBits;
num &= ~conversion.clearBits;
UnsafeNativeMethods.ImmSetConversionStatus(new HandleRef(null, ptr), num, sentence);
UnsafeNativeMethods.ImmReleaseContext(new HandleRef(null, handle), new HandleRef(null, ptr));
}
}
public FComboBoxCodeNameColumn(ImeMode ime)
: base(new FComboBoxCodeNameCell(ime))
{
}
public Control ()
{
if (WindowsFormsSynchronizationContext.AutoInstall)
if (!(SynchronizationContext.Current is WindowsFormsSynchronizationContext))
SynchronizationContext.SetSynchronizationContext (new WindowsFormsSynchronizationContext ());
layout_type = LayoutType.Anchor;
anchor_style = AnchorStyles.Top | AnchorStyles.Left;
is_created = false;
is_visible = true;
is_captured = false;
is_disposed = false;
is_enabled = true;
is_entered = false;
layout_pending = false;
is_toplevel = false;
causes_validation = true;
has_focus = false;
layout_suspended = 0;
mouse_clicks = 1;
tab_index = -1;
cursor = null;
right_to_left = RightToLeft.Inherit;
border_style = BorderStyle.None;
background_color = Color.Empty;
dist_right = 0;
dist_bottom = 0;
tab_stop = true;
ime_mode = ImeMode.Inherit;
use_compatible_text_rendering = true;
show_keyboard_cues = false;
show_focus_cues = SystemInformation.MenuAccessKeysUnderlined;
use_wait_cursor = false;
backgroundimage_layout = ImageLayout.Tile;
use_compatible_text_rendering = Application.use_compatible_text_rendering;
padding = this.DefaultPadding;
maximum_size = new Size();
minimum_size = new Size();
margin = this.DefaultMargin;
auto_size_mode = AutoSizeMode.GrowOnly;
control_style = ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint |
ControlStyles.Selectable | ControlStyles.StandardClick |
ControlStyles.StandardDoubleClick;
control_style |= ControlStyles.UseTextForAccessibility;
parent = null;
background_image = null;
text = string.Empty;
name = string.Empty;
window_target = new ControlWindowTarget(this);
window = new ControlNativeWindow(this);
child_controls = CreateControlsInstance();
bounds.Size = DefaultSize;
client_size = ClientSizeFromSize (bounds.Size);
client_rect = new Rectangle (Point.Empty, client_size);
explicit_bounds = bounds;
}
public void ResetImeMode() {
ime_mode = DefaultImeMode;
}
/// <summary>
/// 弹出下拉列表
/// </summary>
/// <param name="control">要显示的数据内容控件</param>
/// <returns>用户是否确认数据编辑操作</returns>
public void DropDownControl(Control control)
{
_UserAccept = false;
if (control == null)
{
throw new ArgumentNullException("control");
}
if (_PopupForm == null)
{
_PopupForm = new XPopupForm();
_PopupForm.OwnerControl = this._EditControl;
//_PopupForm.ControlBox = true;
}
Size size = control.GetPreferredSize(new Size(0, 300)); // .Size;
_PopupForm.ClientSize = new Size(
size.Width + 5 + PopupFormSizeFix.Width,
size.Height + 5 + PopupFormSizeFix.Height);
WindowInformation info = new WindowInformation(_PopupForm.Handle);
Rectangle rect2 = info.Bounds;
Rectangle crect2 = info.ClientBounds;
_PopupForm.Controls.Clear();
_PopupForm.Controls.Add(control);
control.Dock = DockStyle.Fill;
if (_PopupForm.ClientSize.Width < control.Width)
{
}
_PopupForm.AutoClose = true;
//_PopupForm.CanGetFocus = true;
//_PopupForm.Visible = true;
//_PopupForm.Show();
ImeMode back = ImeMode.NoControl;
if (this._EditControl != null &&
_EditControl.IsHandleCreated &&
_EditControl.IsDisposed == false &&
_ElementInstance != null)
{
_PopupForm.Owner = this._EditControl.FindForm();
_PopupForm.TopMost = (_PopupForm.Owner != null);
if (this._ElementInstance is DomElement)
{
DomElement element = (DomElement)this._ElementInstance;
if (!(element is DomParagraphFlagElement))
{
element = element.FirstContentElement;
}
if (element == null)
{
goto EndFunction;
}
Rectangle rect = this._EditControl.GetCompositionRect(
element.AbsLeft,
element.AbsTop,
element.Height);
_PopupForm.CompositionRect = rect;
_PopupForm.UpdateComposition();
}
_PopupForm.Show();
if (control is MonthCalendar)
{
MonthCalendar mc = (MonthCalendar)control;
size = mc.Size;
_PopupForm.ClientSize = new Size(
size.Width + PopupFormSizeFix.Width,
size.Height + PopupFormSizeFix.Height);
}
else if (control is DateTimeSelectControl)
{
DateTimeSelectControl dtc = (DateTimeSelectControl)control;
size = dtc.GetPreferredSize(Size.Empty);
_PopupForm.ClientSize = new Size(
size.Width + PopupFormSizeFix.Width,
size.Height + PopupFormSizeFix.Height);
}
if (_PopupForm.CanGetFocus == false)
{
if (ForceFousePopupControl)
{
this._EditControl.Focus();
}
}
back = _EditControl.ImeMode;
_EditControl.ImeMode = ImeMode.Disable;
}//if
_PopupForm.WaitUserSelected();
EndFunction:
_PopupForm.CloseList();
if (_PopupForm != null)
{
_PopupForm.Controls.Clear();
}
if (control != null)
{
control.Dispose();
}
if (_EditControl != null)
{
_EditControl.ImeMode = back;
_EditControl.Focus();
}
//_UserAccept = ( _PopupForm.UserProcessState == UserProcessState.Accept );
}
public FComboBoxCodeNameCell(ImeMode ime)
: base()
{
this.ime = ime;
//this.Style.Format = "d";
}
public MemoAttributeMetadata Create(AttributeMetadata baseMetadata, StringFormat stringFormat, ImeMode imeMode, int?maxLength)
{
var memoAttribute = new MemoAttributeMetadata
{
// Set base properties
SchemaName = baseMetadata.SchemaName,
DisplayName = baseMetadata.DisplayName,
RequiredLevel = baseMetadata.RequiredLevel,
Description = baseMetadata.Description,
// Set extended properties
Format = StringFormat.TextArea,
ImeMode = ImeMode.Disabled,
MaxLength = 500
};
return(memoAttribute);
}
/// <devdoc>
/// Sets the actual IME context value.
/// </devdoc>
public static void SetImeStatus( ImeMode imeMode, IntPtr handle ) {
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, string.Format( CultureInfo.CurrentCulture, "Inside ImeContext.SetImeStatus(ImeMode=[{0}, handle=[{1}])", imeMode, handle ) );
Debug.Indent();
Debug.Assert( imeMode != ImeMode.Inherit, "ImeMode.Inherit is an invalid argument to ImeContext.SetImeStatus" );
if( imeMode == ImeMode.Inherit || imeMode == ImeMode.NoControl ) {
goto cleanup; // No action required
}
ImeMode[] inputLanguageTable = ImeModeConversion.InputLanguageTable;
if (inputLanguageTable == ImeModeConversion.UnsupportedTable) {
goto cleanup; // We only support Japanese, Korean and Chinese IME.
}
int conversion = 0; // Combination of conversion mode values
int sentence = 0; // Sentence mode value
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Warning, "\tSetting IME context to " + imeMode );
if( imeMode == ImeMode.Disable ) {
ImeContext.Disable( handle );
}
else {
// This will make sure the IME is opened.
ImeContext.Enable( handle );
}
switch( imeMode ) {
case ImeMode.NoControl:
case ImeMode.Disable:
break; // No action required
case ImeMode.On:
// IME active mode (CHN = On, JPN = Hiragana, KOR = Hangul).
// Setting ImeMode to Hiragana (or any other active value) will force the IME to get to an active value
// independent on the language.
imeMode = ImeMode.Hiragana;
goto default;
case ImeMode.Off:
// IME direct input (CHN = Off, JPN = Off, KOR = Alpha).
if (inputLanguageTable == ImeModeConversion.JapaneseTable) {
// Japanese IME interprets Close as Off.
goto case ImeMode.Close;
}
// CHN: to differentiate between Close and Off we set the ImeMode to Alpha.
imeMode = ImeMode.Alpha;
goto default;
case ImeMode.Close:
if (inputLanguageTable == ImeModeConversion.KoreanTable) {
// Korean IME has no idea what Close means.
imeMode = ImeMode.Alpha;
goto default;
}
ImeContext.SetOpenStatus( false, handle );
break;
default:
if( ImeModeConversion.ImeModeConversionBits.ContainsKey( imeMode ) ) {
// Update the conversion status
//
ImeModeConversion conversionEntry = (ImeModeConversion) ImeModeConversion.ImeModeConversionBits[imeMode];
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "ImmGetContext(" + handle + ")" );
IntPtr inputContext = UnsafeNativeMethods.ImmGetContext( new HandleRef( null, handle ) );
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "context = " + inputContext );
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "ImmGetConversionStatus(" + inputContext + ", conversion, sentence)" );
UnsafeNativeMethods.ImmGetConversionStatus( new HandleRef( null, inputContext ), ref conversion, ref sentence );
conversion |= conversionEntry.setBits;
conversion &= ~conversionEntry.clearBits;
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "ImmSetConversionStatus(" + inputContext + ", conversion, sentence)" );
bool retval = UnsafeNativeMethods.ImmSetConversionStatus( new HandleRef( null, inputContext ), conversion, sentence );
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Verbose, "ImmReleaseContext(" + handle + ", " + inputContext + ")" );
UnsafeNativeMethods.ImmReleaseContext( new HandleRef( null, handle ), new HandleRef( null, inputContext ) );
}
break;
}
cleanup:
ImeContext.TraceImeStatus( handle );
Debug.Unindent();
}
public DateTimeAttributeMetadata Create(AttributeMetadata baseMetadata, DateTimeFormat dateTimeFormat, ImeMode imeMode)
{
// Create a date time attribute ----Object Initialization
var dateAttribute = new DateTimeAttributeMetadata
{
// Set base properties
SchemaName = baseMetadata.SchemaName,
DisplayName = baseMetadata.DisplayName,
RequiredLevel = baseMetadata.RequiredLevel,
Description = baseMetadata.Description,
// Set extended properties
Format = dateTimeFormat,
ImeMode = imeMode
};
return(dateAttribute);
}
/// <devdoc>
/// Checks if specified ImeMode values are different and raise the event if true.
/// </devdoc>
private void VerifyImeModeChanged( ImeMode oldMode, ImeMode newMode ) {
if( ImeSupported && (DisableImeModeChangedCount == 0) && (newMode != ImeMode.NoControl) ) {
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, string.Format( CultureInfo.CurrentCulture, "Inside VerifyImeModeChanged(oldMode={0}, newMode={1}), this = {2}", oldMode, newMode, this ) );
Debug.Indent();
if( oldMode != newMode ) {
OnImeModeChanged( EventArgs.Empty );
}
Debug.Unindent();
}
}
public EntityAttributeMetadataBuilder MemoAttribute(string schemaName, string displayName, string description, AttributeRequiredLevel requiredLevel, int maxLength, StringFormat format, ImeMode imeMode = ImeMode.Disabled)
{
// Define the primary attribute for the entity
var newAtt = new MemoAttributeMetadata
{
SchemaName = schemaName,
DisplayName = new Label(displayName, 1033),
RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
Description = new Label(description, 1033),
MaxLength = maxLength,
Format = format,
ImeMode = imeMode
};
this.Attributes.Add(newAtt);
return(this);
}
/// <devdoc>
/// Handles the WM_INPUTLANGCHANGE message
/// </devdoc>
/// <internalonly/>
private void WmInputLangChange( ref Message m ) {
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Inside WmInputLangChange(), this = " + this );
Debug.Indent();
// Make sure the IME context is associated with the correct (mapped) mode.
UpdateImeContextMode();
// If detaching IME (setting to English) reset propagating IME mode so when reattaching the IME is set to direct input again.
if( ImeModeConversion.InputLanguageTable == ImeModeConversion.UnsupportedTable ) {
PropagatingImeMode = ImeMode.Off;
}
if( ImeModeConversion.InputLanguageTable == ImeModeConversion.ChineseTable ) {
IgnoreWmImeNotify = false;
}
Form form = FindFormInternal();
if( form != null ) {
InputLanguageChangedEventArgs e = InputLanguage.CreateInputLanguageChangedEventArgs( m );
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Culture=" + e.Culture );
form.PerformOnInputLanguageChanged( e );
}
DefWndProc( ref m );
ImeContext.TraceImeStatus( this );
Debug.Unindent();
}
public EntityAttributeMetadataBuilder MoneyAttribute(string schemaName, string displayName, string description, AttributeRequiredLevel requiredLevel, double?min, double?max, int?precision, int?precisionSource, ImeMode imeMode = ImeMode.Disabled)
{
// Define the primary attribute for the entity
// Create a integer attribute
int languageCode = 1033;
var att = new MoneyAttributeMetadata()
{
// Set base properties
SchemaName = schemaName,
DisplayName = new Label(schemaName, languageCode),
RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
Description = new Label(description, languageCode),
// Set extended properties
Precision = precision,
PrecisionSource = precisionSource,
MaxValue = max,
MinValue = min,
ImeMode = imeMode
};
this.Attributes.Add(att);
return(this);
}
public virtual void RegisterControlByImeMode(ImeMode imeMode)
{
}
public static AttributeMetadata CreateDecimal(decimal? minValue = -100000000000, decimal? maxValue = 100000000000, int? precision = 2, ImeMode? mode = ImeMode.Auto, string formulaDefinition = null)
{
if (precision < DecimalAttributeMetadata.MinSupportedPrecision || precision > DecimalAttributeMetadata.MaxSupportedPrecision)
{
throw new ArgumentOutOfRangeException(nameof(precision), "Precision is out of Range!");
}
if (minValue < (decimal)DecimalAttributeMetadata.MinSupportedValue)
{
throw new ArgumentOutOfRangeException(nameof(minValue), "MinValue is out of Range!");
}
if (maxValue > (decimal)DecimalAttributeMetadata.MaxSupportedValue)
{
throw new ArgumentOutOfRangeException(nameof(maxValue), "MaxValue is out of Range!");
}
return new DecimalAttributeMetadata
{
MaxValue = maxValue,
MinValue = minValue,
Precision = precision,
ImeMode = mode,
FormulaDefinition = formulaDefinition
};
}
public MoneyAttributeMetadata Create(AttributeMetadata baseMetadata, double?maxValue, double?minValue, int?precision, int?precisionSource, ImeMode imeMode)
{
var moneyAttribute = new MoneyAttributeMetadata
{
// Set base properties
SchemaName = baseMetadata.SchemaName,
DisplayName = baseMetadata.DisplayName,
RequiredLevel = baseMetadata.RequiredLevel,
Description = baseMetadata.Description,
// Set extended properties
MaxValue = 1000.00,
MinValue = 0.00,
Precision = 1,
PrecisionSource = 1,
ImeMode = ImeMode.Disabled
};
return(moneyAttribute);
}
public static AttributeMetadata CreateCurrency(double? minValue = -922337203685477, double? maxValue = 922337203685477, int? precision = 2, int? precisionSource = null, ImeMode? mode = ImeMode.Auto, string calculationOf = null, string formulaDefinition = null)
{
return new MoneyAttributeMetadata
{
ImeMode = mode,
MaxValue = maxValue,
MinValue = minValue,
Precision = precision,
PrecisionSource = precisionSource,
CalculationOf = calculationOf,
FormulaDefinition = formulaDefinition
};
}
public static void SetImeStatus(ImeMode imeMode, IntPtr handle)
{
if (imeMode == ImeMode.Inherit)
{
return;
}
if (imeMode == ImeMode.NoControl)
{
return;
}
ImeMode[] inputLanguageTable = ImeModeConversion.InputLanguageTable;
if (inputLanguageTable == ImeModeConversion.UnsupportedTable)
{
return;
}
int num = 0;
int sentence = 0;
if (imeMode == ImeMode.Disable)
{
Disable(handle);
}
else
{
Enable(handle);
}
switch (imeMode)
{
case ImeMode.NoControl:
case ImeMode.Disable:
return;
case ImeMode.On:
imeMode = ImeMode.Hiragana;
goto Label_0079;
case ImeMode.Off:
if (inputLanguageTable == ImeModeConversion.JapaneseTable)
{
break;
}
imeMode = ImeMode.Alpha;
goto Label_0079;
case ImeMode.Close:
break;
default:
goto Label_0079;
}
if (inputLanguageTable == ImeModeConversion.KoreanTable)
{
imeMode = ImeMode.Alpha;
}
else
{
SetOpenStatus(false, handle);
return;
}
Label_0079:
if (ImeModeConversion.ImeModeConversionBits.ContainsKey(imeMode))
{
ImeModeConversion conversion = ImeModeConversion.ImeModeConversionBits[imeMode];
IntPtr ptr = UnsafeNativeMethods.ImmGetContext(new HandleRef(null, handle));
UnsafeNativeMethods.ImmGetConversionStatus(new HandleRef(null, ptr), ref num, ref sentence);
num |= conversion.setBits;
num &= ~conversion.clearBits;
UnsafeNativeMethods.ImmSetConversionStatus(new HandleRef(null, ptr), num, sentence);
UnsafeNativeMethods.ImmReleaseContext(new HandleRef(null, handle), new HandleRef(null, ptr));
}
}
public void AxHost_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
{
var control = new SubAxHost("00000000-0000-0000-0000-000000000000");
Assert.Throws <InvalidEnumArgumentException>("value", () => control.ImeMode = value);
}
